Changeset 3dc6ed6 for lib


Ignore:
Timestamp:
01/07/19 10:36:36 (21 months ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
c0c8843
Parents:
aceeda6
git-author:
Jacob Van Walraven <jcv9@…> (12/18/18 13:44:40)
git-committer:
Jacob Van Walraven <jcv9@…> (01/07/19 10:36:36)
Message:

Add functions to byteswap each packet type of pcapng

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_pcapng.c

    raceeda6 r3dc6ed6  
    4848#define PCAPNG_CUSTOM_TYPE 0x00000BAD
    4949#define PCAPNG_CUSTOM_NONCOPY_TYPE 0x40000BAD
     50#define PCAPNG_DECRYPTION_SECRETS_TYPE 0x0000000A
     51
     52#define PCAPNG_NRB_RECORD_END 0x0000
     53#define PCAPNG_NRB_RECORD_IP4 0x0001
     54#define PCAPNG_NRB_RECORD_IP6 0x0002
     55
     56#define PCAPNG_CUSTOM_OPTION_UTF8 0xBAC
     57#define PCAPNG_CUSTOM_OPTION_BIN 0xBAD
     58#define PCAPNG_CUSTOM_OPTION_UTF8_NONCOPY 0x4BAC
     59#define PCAPNG_CUSTOM_OPTION_BIN_NONCOPY 0x4BAD
    5060
    5161#define PACKET_IS_ENHANCED (pcapng_get_record_type(packet) == PCAPNG_ENHANCED_PACKET_TYPE)
     
    5464
    5565#define PACKET_IS_OLD (pcapng_get_record_type(packet) == PCAPNG_OLD_PACKET_TYPE)
    56 
    5766
    5867#define PCAPNG_IFOPT_TSRESOL 9
     
    188197};
    189198
     199struct pcapng_custom_optheader {
     200        uint16_t optcode;
     201        uint16_t optlen;
     202        uint32_t pen;
     203};
     204struct pcapng_nrb_record {
     205        uint16_t recordtype;
     206        uint16_t recordlen;
     207};
    190208struct pcapng_peeker {
    191209        uint32_t blocktype;
     
    198216#define DATAOUT(x) ((struct pcapng_format_data_out_t*)((x)->format_data))
    199217
     218static char *pcapng_parse_next_option(libtrace_t *libtrace, char **pktbuf,
     219                uint16_t *code, uint16_t *length, pcapng_hdr_t *blockhdr);
     220
    200221static bool pcapng_can_write(libtrace_packet_t *packet) {
    201222        /* Get the linktype */
     
    228249        uint32_t *btype = (uint32_t *)packet->header;
    229250
     251        /* Can be NULL if trace is a dead trace */
    230252        if (DATA(packet->trace) == NULL) {
    231253                return *btype;
     
    238260
    239261static inline uint32_t pcapng_swap32(libtrace_out_t *libtrace, uint32_t value) {
    240         if (DATAOUT(libtrace) == NULL) {
    241                 return value;
    242         }
    243 
    244262        if (DATAOUT(libtrace)->byteswapped) {
    245263                return byteswap32(value);
     
    249267}
    250268static inline uint32_t pcapng_swap16(libtrace_out_t *libtrace, uint32_t value) {
    251         if (DATAOUT(libtrace) == NULL) {
    252                 return value;
    253         }
    254 
    255269        if (DATAOUT(libtrace)->byteswapped) {
    256270                return byteswap16(value);
     
    260274}
    261275static inline uint32_t pcapng_get_blocklen(const libtrace_packet_t *packet) {
    262         struct pcapng_peeker *hdr = (struct pcapng_peeker *)packet->buffer;
    263 
    264         if (DATA(packet->trace) == NULL) {
    265                 return hdr->blocklen;
    266         }
     276        struct pcapng_peeker *hdr = (struct pcapng_peeker *)packet->buffer;
     277
     278        /* Can be NULL is trace is dead trace */
     279        if (DATA(packet->trace) == NULL) {
     280                return hdr->blocklen;
     281        }
     282
     283        if (DATA(packet->trace)->byteswapped) {
     284                return byteswap32(hdr->blocklen);
     285        } else {
     286                return hdr->blocklen;
     287        }
     288}
     289static inline uint16_t pcapng_get_customdata_len(libtrace_packet_t *packet, char *ptr) {
     290        struct pcapng_custom_optheader *hdr = (struct pcapng_custom_optheader *)ptr;
    267291
    268292        if (DATA(packet->trace)->byteswapped) {
    269                 return byteswap32(hdr->blocklen);
     293                return byteswap16(hdr->optlen);
    270294        } else {
    271                 return hdr->blocklen;
    272         }
     295                return hdr->optlen;
     296        }
     297}
     298static inline uint16_t pcapng_get_customdata_optcode(libtrace_packet_t *packet, char *ptr) {
     299        struct pcapng_custom_optheader *hdr = (struct pcapng_custom_optheader *)ptr;
     300
     301        if (DATA(packet->trace)->byteswapped) {
     302                return byteswap16(hdr->optcode);
     303        } else {
     304                return hdr->optcode;
     305        }
     306}
     307static inline uint16_t pcapng_get_nrb_record_type(libtrace_packet_t *packet, char *ptr) {
     308        struct pcapng_nrb_record *hdr = (struct pcapng_nrb_record *)ptr;
     309        if (DATA(packet->trace)->byteswapped) {
     310                return byteswap16(hdr->recordtype);
     311        } else {
     312                return hdr->recordtype;
     313        }
     314}
     315static inline uint16_t pcapng_get_nrb_record_len(libtrace_packet_t *packet, char *ptr) {
     316        struct pcapng_nrb_record *hdr = (struct pcapng_nrb_record *)ptr;
     317        if (DATA(packet->trace)->byteswapped) {
     318                return byteswap16(hdr->recordlen);
     319        } else {
     320                return hdr->recordlen;
     321        }
     322}
     323static uint32_t pcapng_output_options(libtrace_out_t *libtrace, libtrace_packet_t *packet,
     324        char *ptr) {
     325
     326        struct pcapng_optheader opthdr;
     327        uint16_t optcode, optlen;
     328        char *optval = NULL;
     329        char *bodyptr = NULL;
     330        int padding;
     331        void *padding_data;
     332        uint32_t len = 0;
     333        int options = 0;
     334
     335        bodyptr = ptr;
     336
     337        while ((optval = pcapng_parse_next_option(packet->trace, &bodyptr,
     338                        &optcode, &optlen, (pcapng_hdr_t *) packet->buffer))) {
     339
     340                opthdr.optcode = byteswap16(optcode);
     341                /* optlen contains the length of the option value without any padding bits,
     342                 * it needs to be padded to 32 bits */
     343                opthdr.optlen = byteswap16(optlen);
     344
     345                wandio_wwrite(DATAOUT(libtrace)->file, &opthdr, sizeof(opthdr));
     346                wandio_wwrite(DATAOUT(libtrace)->file, optval, optlen);
     347
     348                /* calculate any required padding */
     349                padding = optlen % 4;
     350                if (padding) { padding = 4 - padding; }
     351                padding_data = calloc(1, padding);
     352                /* output the padding */
     353                wandio_wwrite(DATAOUT(libtrace)->file, padding_data, padding);
     354                free(padding_data);
     355
     356                len += sizeof(opthdr) + optlen;
     357                options = 1;
     358        }
     359
     360        if (options) {
     361                struct pcapng_optheader optftr;
     362                optftr.optcode = 0;
     363                optftr.optlen = 0;
     364                wandio_wwrite(DATAOUT(libtrace)->file, &optftr, sizeof(optftr));
     365                len += sizeof(optftr);
     366        }
     367
     368        return len;
     369}
     370static uint32_t pcapng_output_interface_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     371        pcapng_int_t *cur = (pcapng_int_t *)packet->header;
     372        pcapng_int_t hdr;
     373        char *bodyptr = NULL;
     374
     375        /* If trace is deadtrace or the byte ordering is the same just output it */
     376        if ((DATA(packet->trace) == NULL) ||
     377                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     378                uint32_t len = pcapng_get_blocklen(packet);
     379                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     380                return len;
     381        }
     382
     383        /* Byteswap the headers */
     384        hdr.blocktype = byteswap32(cur->blocktype);
     385        hdr.blocklen = byteswap32(cur->blocklen);
     386        hdr.linktype = byteswap16(cur->linktype);
     387        hdr.reserved = byteswap16(cur->reserved);
     388        hdr.snaplen = byteswap32(cur->snaplen);
     389
     390        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     391        /* output any options */
     392        bodyptr = (char *)packet->buffer + sizeof(hdr);
     393        pcapng_output_options(libtrace, packet, bodyptr);
     394        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     395
     396        return hdr.blocklen;
     397}
     398static uint32_t pcapng_output_simple_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     399        pcapng_spkt_t *cur = (pcapng_spkt_t *)packet->header;
     400        pcapng_spkt_t hdr;
     401        uint32_t len;
     402        char *bodyptr = NULL;
     403
     404        /* If trace is deadtrace or the byte ordering is the same just output it */
     405        if ((DATA(packet->trace) == NULL) ||
     406                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     407                len = pcapng_get_blocklen(packet);
     408                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     409                return len;
     410        }
     411
     412        hdr.blocktype = byteswap32(cur->blocktype);
     413        hdr.blocklen = byteswap32(cur->blocklen);
     414        hdr.wlen = byteswap32(cur->wlen);
     415
     416        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     417
     418        /* output the packet payload */
     419        bodyptr = (char *)packet->buffer + sizeof(hdr);
     420        len = pcapng_get_blocklen(packet) - sizeof(hdr) - sizeof(hdr.blocklen);
     421        wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, len);
     422
     423        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     424
     425        return hdr.blocklen;
     426}
     427static uint32_t pcapng_output_old_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     428        pcapng_opkt_t *cur = (pcapng_opkt_t *)packet->header;
     429        pcapng_opkt_t hdr;
     430        uint32_t len;
     431        char *bodyptr = NULL;
     432
     433        /* If trace is deadtrace or the byte ordering is the same just output it */
     434        if ((DATA(packet->trace) == NULL) ||
     435                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     436                len = pcapng_get_blocklen(packet);
     437                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     438                return len;
     439        }
     440
     441        hdr.blocktype = byteswap32(cur->blocktype);
     442        hdr.blocklen = byteswap32(cur->blocklen);
     443        hdr.interfaceid = byteswap16(cur->interfaceid);
     444        hdr.drops = byteswap16(cur->drops);
     445        hdr.timestamp_high = byteswap32(cur->timestamp_high);
     446        hdr.timestamp_low = byteswap32(cur->timestamp_low);
     447        hdr.caplen = byteswap32(cur->caplen);
     448        hdr.wlen = byteswap32(cur->wlen);
     449
     450        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     451
     452        /* output the packet payload */
     453        bodyptr = (char *)packet->buffer + sizeof(hdr);
     454        len = pcapng_get_blocklen(packet) - sizeof(hdr) - sizeof(hdr.blocklen);
     455        wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, len);
     456
     457        /* output any options if present */
     458        pcapng_output_options(libtrace, packet, bodyptr);
     459
     460        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     461
     462
     463        return hdr.blocklen;
     464}
     465static uint32_t pcapng_output_nameresolution_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     466        pcapng_nrb_t *cur = (pcapng_nrb_t *)packet->buffer;
     467        pcapng_nrb_t hdr;
     468        char *bodyptr = NULL;
     469        int padding;
     470        void *padding_data;
     471
     472        /* If trace is deadtrace or the byte ordering is the same just output it */
     473        if ((DATA(packet->trace) == NULL) ||
     474                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     475                uint32_t len = pcapng_get_blocklen(packet);
     476                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     477                return len;
     478        }
     479
     480        hdr.blocktype = byteswap32(cur->blocktype);
     481        hdr.blocklen = byteswap32(cur->blocklen);
     482
     483        /* output the header */
     484        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     485        bodyptr = (char *)packet->buffer + sizeof(hdr);
     486
     487        struct pcapng_nrb_record *nrbr = (struct pcapng_nrb_record *)bodyptr;
     488
     489        uint16_t record_type = pcapng_get_nrb_record_type(packet, bodyptr);
     490        while (record_type == PCAPNG_NRB_RECORD_IP4 ||
     491                record_type == PCAPNG_NRB_RECORD_IP6) {
     492
     493                struct pcapng_nrb_record nrb;
     494
     495                /* recordlen contains the total size of the record block */
     496                uint16_t recordlen = pcapng_get_nrb_record_len(packet, bodyptr);
     497
     498                nrb.recordtype = byteswap16(nrbr->recordtype);
     499                nrb.recordlen = byteswap16(nrbr->recordlen);
     500
     501                /* output the record header */
     502                wandio_wwrite(DATAOUT(libtrace)->file, &nrb, sizeof(nrb));
     503                bodyptr += sizeof(nrb);
     504
     505                /* output the record data */
     506                wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, recordlen - sizeof(nrb));
     507                bodyptr += recordlen - sizeof(nrb);
     508
     509                /* calculate any required padding. record also contains the 8 byte header
     510                 * but we dont need to subtract it because it will be removed with % 4 */
     511                padding = recordlen % 4;
     512                if (padding) { padding = 4 - padding; }
     513                padding_data = calloc(1, padding);
     514                /* output the padding */
     515                wandio_wwrite(DATAOUT(libtrace)->file, padding_data, padding);
     516                free(padding_data);
     517
     518                /* get the next record if it exists */
     519                nrbr = (struct pcapng_nrb_record *)bodyptr;
     520                record_type = pcapng_get_nrb_record_type(packet, bodyptr);
     521        }
     522
     523        /* output nrb record end block */
     524        struct pcapng_nrb_record nrbftr;
     525        nrbftr.recordtype = PCAPNG_NRB_RECORD_END;
     526        nrbftr.recordlen = 0;
     527        wandio_wwrite(DATAOUT(libtrace)->file, &nrbftr, sizeof(nrbftr));
     528
     529        /* output any options if present */
     530        pcapng_output_options(libtrace, packet, bodyptr);
     531
     532        /* and print out rest of the header */
     533        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     534
     535        return hdr.blocklen;
     536}
     537static uint32_t pcapng_output_custom_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     538        pcapng_custom_t *cur = (pcapng_custom_t *)packet->buffer;
     539        pcapng_custom_t hdr;
     540        char *bodyptr = (char *)packet->buffer;
     541        int padding;
     542        void *padding_data;
     543
     544        /* If trace is deadtrace or the byte ordering is the same just output it */
     545        if ((DATA(packet->trace) == NULL) ||
     546                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     547                uint32_t len = pcapng_get_blocklen(packet);
     548                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     549                return len;
     550        }
     551
     552        hdr.blocktype = byteswap32(cur->blocktype);
     553        hdr.blocklen = byteswap32(cur->blocklen);
     554        hdr.pen = byteswap32(cur->blocklen);
     555
     556        /* output the header */
     557        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     558        bodyptr += sizeof(hdr);
     559
     560        /* get header for custom data ? if it exists */
     561        struct pcapng_custom_optheader *copt = (struct pcapng_custom_optheader *)bodyptr;
     562
     563        uint16_t optcode = pcapng_get_customdata_optcode(packet, bodyptr);
     564        while (optcode == PCAPNG_CUSTOM_OPTION_UTF8 || optcode == PCAPNG_CUSTOM_OPTION_BIN ||
     565                optcode == PCAPNG_CUSTOM_OPTION_UTF8_NONCOPY ||
     566                optcode == PCAPNG_CUSTOM_OPTION_BIN_NONCOPY) {
     567
     568                struct pcapng_custom_optheader opt;
     569                /* get the true value for the custom datas length */
     570                uint16_t optlen = pcapng_get_customdata_len(packet, bodyptr);
     571
     572                opt.optcode = byteswap16(copt->optcode);
     573                opt.optlen = byteswap16(copt->optlen);
     574                opt.pen = byteswap32(copt->pen);
     575
     576                /* output the header */
     577                wandio_wwrite(DATAOUT(libtrace)->file, &opt, sizeof(opt));
     578                bodyptr += sizeof(copt);
     579
     580                /* output the custom data */
     581                wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, optlen - sizeof(opt.pen));
     582                /* oplen includes length of pen but we have already accounted for it so we need
     583                 * remove it from the bodyptr */
     584                bodyptr += optlen - sizeof(opt.pen);
     585
     586                /* calculate any required padding. optlen also contains the 4 bytes for pen
     587                 * but we dont need to subtract them cause they will be removed with % 4 */
     588                padding = optlen % 4;
     589                if (padding) { padding = 4 - padding; }
     590                padding_data = calloc(1, padding);
     591                /* output the padding */
     592                wandio_wwrite(DATAOUT(libtrace)->file, padding_data, padding);
     593                free(padding_data);
     594
     595                /* get the next custom data? */
     596                copt = (struct pcapng_custom_optheader *)bodyptr;
     597                /* get the next opcode */
     598                optcode = pcapng_get_customdata_optcode(packet, bodyptr);
     599        }
     600
     601        /* now print out any options */
     602        pcapng_output_options(libtrace, packet, bodyptr);
     603
     604        /* and print out rest of the header */
     605        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     606
     607        return hdr.blocklen;
     608}
     609static uint32_t pcapng_output_enhanced_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     610        pcapng_epkt_t *cur = (pcapng_epkt_t *)packet->buffer;
     611        pcapng_epkt_t hdr;
     612        char *bodyptr = NULL;
     613        uint32_t len;
     614
     615        /* If trace is deadtrace or the byte ordering is the same just output it */
     616        if ((DATA(packet->trace) == NULL) ||
     617                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     618                len = pcapng_get_blocklen(packet);
     619                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     620                return len;
     621        }
     622
     623        hdr.blocktype = byteswap32(cur->blocktype);
     624        hdr.blocklen = byteswap32(cur->blocklen);
     625        hdr.interfaceid = byteswap32(cur->interfaceid);
     626        hdr.timestamp_high = byteswap32(cur->timestamp_high);
     627        hdr.timestamp_low = byteswap32(cur->timestamp_low);
     628        hdr.caplen = byteswap32(cur->caplen);
     629        hdr.wlen = byteswap32(cur->wlen);
     630
     631        /* output beginning of header */
     632        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     633
     634        /* output the packet payload */
     635        bodyptr = (char *)packet->buffer + sizeof(hdr);
     636        len = pcapng_get_blocklen(packet) - sizeof(hdr) - sizeof(hdr.blocklen);
     637        wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, len);
     638
     639        /* output any options */
     640        pcapng_output_options(libtrace, packet, bodyptr);
     641
     642        /* output end of header */
     643        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     644
     645        return hdr.blocklen;
     646}
     647static uint32_t pcapng_output_interfacestats_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     648        pcapng_stats_t *cur = (pcapng_stats_t *)packet->header;
     649        pcapng_stats_t hdr;
     650        char *bodyptr = NULL;
     651
     652        /* If trace is deadtrace or the byte ordering is the same just output it */
     653        if ((DATA(packet->trace) == NULL) ||
     654                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     655                uint32_t len = pcapng_get_blocklen(packet);
     656                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     657                return len;
     658        }
     659
     660        hdr.blocktype = byteswap32(cur->blocktype);
     661        hdr.blocklen = byteswap32(cur->blocklen);
     662        hdr.interfaceid = byteswap32(cur->interfaceid);
     663        hdr.timestamp_high = byteswap32(cur->timestamp_high);
     664        hdr.timestamp_low = byteswap32(cur->timestamp_low);
     665
     666        /* output interface stats header */
     667        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     668        /* output any options if present */
     669        bodyptr = (char *)packet->buffer + sizeof(hdr);
     670        pcapng_output_options(libtrace, packet, bodyptr);
     671        /* output rest of interface stats header */
     672        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     673
     674        return hdr.blocklen;
    273675}
    274676
     
    597999                         * till the next section header needs to be byteswapped. The next header
    5981000                         * will determine if we need to continue swapping bytes */
    599                         if (DATA(libtrace)->byteswapped) {
     1001                        if (DATA(packet->trace)->byteswapped) {
    6001002                                DATAOUT(libtrace)->byteswapped = true;
    6011003                        } else {
     
    6111013                }
    6121014                case PCAPNG_INTERFACE_TYPE: {
    613                         wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer,
    614                                 pcapng_get_blocklen(packet));
    615 
    6161015                        /* increment the interface id */
    617                         DATAOUT(libtrace)->nextintid += 1;
    618 
    619                         return pcapng_get_blocklen(packet);
     1016                        DATAOUT(libtrace)->nextintid += 1;
     1017
     1018                        return pcapng_output_interface_packet(libtrace, packet);
    6201019                }
    6211020                case PCAPNG_OLD_PACKET_TYPE: {
    622                         wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer,
    623                                 pcapng_get_blocklen(packet));
    624 
    625                         return pcapng_get_blocklen(packet);
     1021                        return pcapng_output_old_packet(libtrace, packet);
    6261022                }
    6271023                case PCAPNG_SIMPLE_PACKET_TYPE: {
     
    6321028                                return -1;
    6331029                        }
    634 
    635                         wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer,
    636                                 pcapng_get_blocklen(packet));
    637 
    638                         return pcapng_get_blocklen(packet);
     1030                        return pcapng_output_simple_packet(libtrace, packet);
    6391031                }
    6401032                case PCAPNG_NAME_RESOLUTION_TYPE: {
    641                         wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer,
    642                                 pcapng_get_blocklen(packet));
    643 
    644                         return pcapng_get_blocklen(packet);
     1033                        return pcapng_output_nameresolution_packet(libtrace, packet);
    6451034                }
    6461035                case PCAPNG_INTERFACE_STATS_TYPE: {
     
    6511040                                return -1;
    6521041                        }
    653 
    654                         wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer,
    655                                 pcapng_get_blocklen(packet));
    656 
    657                         return pcapng_get_blocklen(packet);
     1042                        return pcapng_output_interfacestats_packet(libtrace, packet);
    6581043                }
    6591044                case PCAPNG_ENHANCED_PACKET_TYPE: {
     
    6641049                                return -1;
    6651050                        }
    666 
    667                         wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer,
    668                                 pcapng_get_blocklen(packet));
    669 
    670                         return pcapng_get_blocklen(packet);
     1051                        return pcapng_output_enhanced_packet(libtrace, packet);
    6711052                }
    6721053                case PCAPNG_CUSTOM_TYPE: {
    673                         if (DATA(libtrace)->byteswapped == DATAOUT(libtrace)->byteswapped) {
    674                                 wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer,
    675                                         pcapng_get_blocklen(packet));
    676                         } else {
    677 
    678                         }
    679 
    680                         return pcapng_get_blocklen(packet);
     1054                        return pcapng_output_custom_packet(libtrace, packet);
     1055                }
     1056                case PCAPNG_DECRYPTION_SECRETS_TYPE: {
     1057                        /* Silently discard these until they are supported */
     1058                        struct pcapng_peeker *hdr = (struct pcapng_peeker *)packet->header;
     1059                        return hdr->blocklen;
    6811060                }
    6821061                default: {
Note: See TracChangeset for help on using the changeset viewer.