Changeset ef5ba20 for lib


Ignore:
Timestamp:
01/16/19 13:52:38 (21 months ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
d51e5d0
Parents:
629b19b
Message:

add abilty to get custom option from meta packets, add abilty to get entire section from meta packet, meta api now returns libtrace_meta_t structure

Location:
lib
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • lib/dagformat.h

    r977e0db ref5ba20  
    109109} dag_sec_t;
    110110
     111struct dag_opthdr {
     112        uint16_t optcode;
     113        uint16_t optlen;
     114};
     115
    111116#ifdef WIN32
    112117#pragma pack(pop)
  • lib/format_atmhdr.c

    r977e0db ref5ba20  
    209209        NULL,                           /* get_timespec */
    210210        NULL,                           /* get_seconds */
    211         NULL,                           /* get_meta_data */
     211        NULL,                           /* get_meta_section */
     212        NULL,                           /* get_meta_section_item */
    212213        NULL,                           /* seek_erf */
    213214        NULL,                           /* seek_timeval */
  • lib/format_bpf.c

    r977e0db ref5ba20  
    632632        NULL,                   /* get_timespec */
    633633        NULL,                   /* get_seconds */
    634         NULL,                   /* get_meta_data */
     634        NULL,                   /* get_meta_section */
     635        NULL,                   /* get_meta_section_item */
    635636        NULL,                   /* seek_erf */
    636637        NULL,                   /* seek_timeval */
     
    684685        NULL,                   /* get_timespec */
    685686        NULL,                   /* get_seconds */
    686         NULL,                   /* get_meta_data */
     687        NULL,                   /* get_meta_section */
     688        NULL,                   /* get_meta_section_item */
    687689        NULL,                   /* seek_erf */
    688690        NULL,                   /* seek_timeval */
  • lib/format_dag24.c

    r977e0db ref5ba20  
    542542        NULL,                           /* seek_timeval */
    543543        NULL,                           /* seek_seconds */
    544         NULL,                           /* get_meta_data */
     544        NULL,                           /* get_meta_section */
     545        NULL,                           /* get_meta_section_item */
    545546        erf_get_capture_length,         /* get_capture_length */
    546547        erf_get_wire_length,            /* get_wire_length */
  • lib/format_dag25.c

    r977e0db ref5ba20  
    16251625        NULL,                           /* get_seconds */
    16261626        NULL,                           /* get_timespec */
    1627         NULL,                           /* get_meta_data */
     1627        NULL,                           /* get_meta_section */
     1628        NULL,                           /* get_meta_section_item */
    16281629        NULL,                           /* seek_erf */
    16291630        NULL,                           /* seek_timeval */
  • lib/format_dpdk.c

    r977e0db ref5ba20  
    22532253        NULL,                               /* seek_timeval */
    22542254        NULL,                               /* seek_seconds */
    2255         NULL,                               /* get_meta_data */
     2255        NULL,                               /* get_meta_section */
     2256        NULL,                               /* get_meta_section_item */
    22562257        dpdk_get_capture_length,            /* get_capture_length */
    22572258        dpdk_get_wire_length,               /* get_wire_length */
  • lib/format_dpdkndag.c

    r977e0db ref5ba20  
    749749        NULL,                   /* seek_timeval */
    750750        NULL,                   /* seek_seconds */
    751         NULL,                   /* get_meta_data */
     751        NULL,                   /* get_meta_section */
     752        NULL,                   /* get_meta_section_item */
    752753        erf_get_capture_length, /* get_capture_length */
    753754        erf_get_wire_length,    /* get_wire_length */
  • lib/format_duck.c

    r977e0db ref5ba20  
    363363        NULL,                           /* get_timespec */
    364364        NULL,                           /* get_seconds */
    365         NULL,                           /* get_meta_data */
     365        NULL,                           /* get_meta_section */
     366        NULL,                           /* get_meta_section_item */
    366367        NULL,                           /* seek_erf */
    367368        NULL,                           /* seek_timeval */
  • lib/format_erf.c

    r7aa03d9 ref5ba20  
    914914}
    915915
     916/* An ERF provenance packet can contain multiple sections of the same type per packet,
     917 * Need to think of a way to handle this currently the first found is returned*/
     918void *erf_get_meta_section(libtrace_packet_t *packet, uint32_t section) {
     919
     920        void *ptr;
     921        dag_record_t *hdr;
     922        dag_sec_t *sec;
     923        uint16_t tmp;
     924        uint16_t remaining;
     925        uint16_t curr_sec = 0;
     926        int in_section = 0;
     927
     928        if (packet->buffer == NULL) { return NULL; }
     929
     930        hdr = (dag_record_t *)packet->buffer;
     931        ptr = packet->payload;
     932
     933        /* ensure this packet is a meta packet */
     934        if ((hdr->type & 127) != 27) { return NULL; }
     935        /* set remaining to size of packet minus header length */
     936        remaining = ntohs(hdr->rlen) - 24;
     937
     938        /* setup structure to hold the result */
     939        libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
     940        result->section = section;
     941        result->num = 0;
     942
     943        while (remaining > sizeof(dag_sec_t) && curr_sec != 0xFFFF) {
     944
     945                /* Get the current section/option header */
     946                sec = (dag_sec_t *)ptr;
     947
     948                if (ntohs(sec->type) == ERF_PROV_SECTION_CAPTURE
     949                        || ntohs(sec->type) == ERF_PROV_SECTION_HOST
     950                        || ntohs(sec->type) == ERF_PROV_SECTION_MODULE
     951                        || ntohs(sec->type) == ERF_PROV_SECTION_INTERFACE) {
     952
     953                        if (in_section == 0) {
     954                                curr_sec = ntohs(sec->type);
     955                        } else {
     956                                /* Used to indicate section end */
     957                                curr_sec = 0xFFFF;
     958                        }
     959                }
     960
     961                /* If the current section the requested one and this is not
     962                 * a section header */
     963                if (section == curr_sec &&
     964                        ntohs(sec->type) != ERF_PROV_SECTION_CAPTURE
     965                        && ntohs(sec->type) != ERF_PROV_SECTION_HOST
     966                        && ntohs(sec->type) != ERF_PROV_SECTION_MODULE
     967                        && ntohs(sec->type) != ERF_PROV_SECTION_INTERFACE) {
     968
     969                        /* Indicate a section has been found */
     970                        in_section = 1;
     971
     972                        result->num += 1;
     973                        if (result->num == 1) {
     974                                result->items = malloc(sizeof(libtrace_meta_item_t));
     975                        } else {
     976                                result->items = realloc(result->items,
     977                                        result->num*sizeof(libtrace_meta_item_t));
     978                        }
     979                        result->items[result->num-1].option = ntohs(sec->type);
     980                        result->items[result->num-1].len = ntohs(sec->len);
     981                        result->items[result->num-1].data_type = 0;
     982                        result->items[result->num-1].data = malloc(ntohs(sec->len));
     983                        memcpy(result->items[result->num-1].data,
     984                                ptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     985
     986                }
     987
     988                /* Update remaining and ptr. Also account for any padding */
     989                if ((ntohs(sec->len) % 4) != 0) {
     990                        tmp = ntohs(sec->len) + (4 - (ntohs(sec->len) % 4)) + sizeof(dag_sec_t);
     991                } else {
     992                        tmp = ntohs(sec->len) + sizeof(dag_sec_t);
     993                }
     994                remaining -= tmp;
     995                ptr += tmp;
     996        }
     997
     998        /* If the result structure has result matches were found */
     999        if (result->num > 0) {
     1000                return (void *)result;
     1001        } else {
     1002                free(result);
     1003                return NULL;
     1004        }
     1005}
     1006
    9161007/* Returns a pointer to the beginning of the section or NULL if not found */
    917 void *erf_get_meta_data(libtrace_packet_t *packet, uint32_t section_type, uint16_t section) {
     1008void *erf_get_meta_section_option(libtrace_packet_t *packet, uint32_t section, uint16_t option) {
    9181009
    9191010        uint32_t remaining;
     
    9221013        dag_record_t *hdr;
    9231014        uint16_t curr_sec;
     1015        uint16_t tmp;
    9241016
    9251017        if (packet->buffer == NULL) { return NULL; }
     
    9341026        if ((hdr->type & 127) != 27) { return NULL; }
    9351027
    936         sec = (dag_sec_t *)bodyptr;
    937         /* loop till we find the correct section within the correct section type
    938          * and enough payload is remaining */
    939         while (((ntohs(sec->type) != section) || (section_type != curr_sec))
    940                 && (remaining > sizeof(dag_sec_t))) {
     1028        /* setup structure to hold the result */
     1029        libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
     1030        result->section = section;
     1031        result->num = 0;
     1032
     1033        /* loop over the entire packet */
     1034        while (remaining > sizeof(dag_sec_t)) {
     1035
     1036                sec = (dag_sec_t *)bodyptr;
    9411037
    9421038                if (ntohs(sec->type) == ERF_PROV_SECTION_CAPTURE
     
    9481044                }
    9491045
    950                 /* jump over any padding (padded to 32bits/4bytes) */
     1046                /* if this section and option is one we want */
     1047                if (curr_sec == section && ntohs(sec->type) == option) {
     1048
     1049                        result->num += 1;
     1050
     1051                        if (result->num == 1) {
     1052                                result->items = malloc(sizeof(libtrace_meta_item_t));
     1053                        } else {
     1054                                result->items = realloc(result->items,
     1055                                        result->num*sizeof(libtrace_meta_item_t));
     1056                        }
     1057
     1058                        result->items[result->num-1].option = ntohs(sec->type);
     1059                        result->items[result->num-1].len = ntohs(sec->len);
     1060                        result->items[result->num-1].data_type = 0;
     1061                        result->items[result->num-1].data = calloc(1, ntohs(sec->len));
     1062
     1063                        memcpy(result->items[result->num-1].data,
     1064                                bodyptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     1065
     1066                }
     1067
     1068                /* Update remaining and bodyptr and account for any padding */
    9511069                if ((ntohs(sec->len) % 4) != 0) {
    952                         remaining -= ntohs(sec->len) + (4 - (ntohs(sec->len) % 4));
    953                         bodyptr += ntohs(sec->len) + (4 - (ntohs(sec->len) % 4));
    954                 } else {
    955                         remaining -= ntohs(sec->len);
    956                         bodyptr += ntohs(sec->len);
    957                 }
    958                 remaining -= sizeof(dag_sec_t);
    959                 bodyptr += sizeof(dag_sec_t);
    960 
    961                 sec = (dag_sec_t *)bodyptr;
    962         }
    963         /* if found return pointer to the beginning of the section */
    964         if (ntohs(sec->type) == section && curr_sec == section_type) {
    965                 return (void *)bodyptr;
     1070                        tmp = ntohs(sec->len) + (4 - (ntohs(sec->len) % 4)) + sizeof(dag_sec_t);
     1071                } else {
     1072                        tmp = ntohs(sec->len) + sizeof(dag_sec_t);
     1073                }
     1074                remaining -= tmp;
     1075                bodyptr += tmp;
     1076        }
     1077
     1078        /* If the result structure has result matches were found */
     1079        if (result->num > 0) {
     1080                return (void *)result;
    9661081        } else {
     1082                free(result);
    9671083                return NULL;
    9681084        }
     
    9961112        NULL,                           /* probe filename */
    9971113        erf_probe_magic,                /* probe magic */
    998         erf_init_input,                 /* init_input */       
     1114        erf_init_input,                 /* init_input */
    9991115        erf_config_input,               /* config_input */
    10001116        erf_start_input,                /* start_input */
     
    10171133        NULL,                           /* get_timespec */
    10181134        NULL,                           /* get_seconds */
    1019         erf_get_meta_data,              /* get_meta_data */
     1135        erf_get_meta_section,           /* get_meta_section */
     1136        erf_get_meta_section_option,    /* get_meta_section_option */
    10201137        erf_seek_erf,                   /* seek_erf */
    10211138        NULL,                           /* seek_timeval */
     
    10421159        NULL,                           /* probe filename */
    10431160        NULL,           /* probe magic */
    1044         erf_init_input,                 /* init_input */       
     1161        erf_init_input,                 /* init_input */
    10451162        erf_config_input,               /* config_input */
    10461163        rawerf_start_input,             /* start_input */
     
    10631180        NULL,                           /* get_timespec */
    10641181        NULL,                           /* get_seconds */
    1065         erf_get_meta_data,              /* get_meta_data */
     1182        erf_get_meta_section,           /* get_meta_section */
     1183        erf_get_meta_section_option,    /* get_meta_section_option */
    10661184        erf_seek_erf,                   /* seek_erf */
    10671185        NULL,                           /* seek_timeval */
  • lib/format_erf.h

    re7132d6 ref5ba20  
    118118int erf_is_color_type(uint8_t erf_type);
    119119
    120 void *erf_get_meta_data(libtrace_packet_t *packet, uint32_t section_type,
    121         uint16_t section);
     120void *erf_get_meta_section(libtrace_packet_t *packet, uint32_t section);
     121void *erf_get_meta_section_option(libtrace_packet_t *packet, uint32_t section,
     122        uint16_t option);
    122123
    123124#endif
  • lib/format_etsilive.c

    r977e0db ref5ba20  
    686686        NULL,                           /* get_timespec */
    687687        NULL,                           /* get_seconds */
    688         NULL,                           /* get_meta_data */
     688        NULL,                           /* get_meta_section */
     689        NULL,                           /* get_meta_section_item */
    689690        NULL,                           /* seek_erf */
    690691        NULL,                           /* seek_timeval */
  • lib/format_legacy.c

    r977e0db ref5ba20  
    536536        NULL,                           /* get_timespec */
    537537        NULL,                           /* get_seconds */
    538         NULL,                           /* get_meta_data */
     538        NULL,                           /* get_meta_section */
     539        NULL,                           /* get_meta_section_item */
    539540        NULL,                           /* seek_erf */
    540541        NULL,                           /* seek_timeval */
     
    582583        NULL,                           /* get_timespec */
    583584        NULL,                           /* get_seconds */
    584         NULL,                           /* get_meta_data */
     585        NULL,                           /* get_meta_section */
     586        NULL,                           /* get_meta_section_item */
    585587        NULL,                           /* seek_erf */
    586588        NULL,                           /* seek_timeval */
     
    628630        NULL,                           /* get_timespec */
    629631        NULL,                           /* get_seconds */
    630         NULL,                           /* get_meta_data */
     632        NULL,                           /* get_meta_section */
     633        NULL,                           /* get_meta_section_item */
    631634        NULL,                           /* seek_erf */
    632635        NULL,                           /* seek_timeval */
     
    674677        NULL,                           /* get_timespec */
    675678        NULL,                           /* get_seconds */
    676         NULL,                           /* get_meta_data */
     679        NULL,                           /* get_meta_section */
     680        NULL,                           /* get_meta_section_item */
    677681        NULL,                           /* seek_erf */
    678682        NULL,                           /* seek_timeval */
  • lib/format_linux_int.c

    r977e0db ref5ba20  
    519519        linuxnative_get_timespec,       /* get_timespec */
    520520        NULL,                           /* get_seconds */
    521         NULL,                           /* get_meta_data */
     521        NULL,                           /* get_meta_section */
     522        NULL,                           /* get_meta_section_item */
    522523        NULL,                           /* seek_erf */
    523524        NULL,                           /* seek_timeval */
     
    581582        linuxnative_get_timespec,       /* get_timespec */
    582583        NULL,                           /* get_seconds */
    583         NULL,                           /* get_meta_data */
     584        NULL,                           /* get_meta_section */
     585        NULL,                           /* get_meta_section_item */
    584586        NULL,                           /* seek_erf */
    585587        NULL,                           /* seek_timeval */
  • lib/format_linux_ring.c

    r977e0db ref5ba20  
    840840        linuxring_get_timespec,         /* get_timespec */
    841841        NULL,                           /* get_seconds */
    842         NULL,                           /* get_meta_data */
     842        NULL,                           /* get_meta_section */
     843        NULL,                           /* get_meta_section_item */
    843844        NULL,                           /* seek_erf */
    844845        NULL,                           /* seek_timeval */
     
    904905        linuxring_get_timespec,         /* get_timespec */
    905906        NULL,                           /* get_seconds */
    906         NULL,                           /* get_meta_data */
     907        NULL,                           /* get_meta_section */
     908        NULL,                           /* get_meta_section_item */
    907909        NULL,                           /* seek_erf */
    908910        NULL,                           /* seek_timeval */
  • lib/format_ndag.c

    r977e0db ref5ba20  
    15231523        NULL,                   /* get_seconds */
    15241524        NULL,                   /* get_timespec */
    1525         NULL,                   /* get_meta_data */
     1525        NULL,                   /* get_meta_section */
     1526        NULL,                   /* get_meta_section_item */
    15261527        NULL,                   /* seek_erf */
    15271528        NULL,                   /* seek_timeval */
  • lib/format_pcap.c

    r977e0db ref5ba20  
    869869        NULL,                           /* get_seconds */
    870870        NULL,                           /* get_timespec */
    871         NULL,                           /* get_meta_data */
     871        NULL,                           /* get_meta_section */
     872        NULL,                           /* get_meta_section_item */
    872873        NULL,                           /* seek_erf */
    873874        NULL,                           /* seek_timeval */
     
    915916        NULL,                           /* get_seconds */
    916917        NULL,                           /* get_timespec */
    917         NULL,                           /* get_meta_data */
     918        NULL,                           /* get_meta_section */
     919        NULL,                           /* get_meta_section_item */
    918920        NULL,                           /* seek_erf */
    919921        NULL,                           /* seek_timeval */
  • lib/format_pcapfile.c

    r977e0db ref5ba20  
    791791        pcapfile_get_timespec,          /* get_timespec */
    792792        NULL,                           /* get_seconds */
    793         NULL,                           /* get_meta_data */
     793        NULL,                           /* get_meta_section */
     794        NULL,                           /* get_meta_section_item */
    794795        NULL,                           /* seek_erf */
    795796        NULL,                           /* seek_timeval */
  • lib/format_pcapng.c

    r7aa03d9 ref5ba20  
    21002100}
    21012101
    2102 void *pcapng_get_meta_data(libtrace_packet_t *packet, uint32_t section_type,
    2103         uint16_t section) {
     2102static void *pcapng_jump_to_options(libtrace_packet_t *packet) {
     2103
     2104        struct pcapng_peeker *hdr = (struct pcapng_peeker *)packet->buffer;
     2105        void *ptr = packet->buffer;
     2106        uint32_t blocktype;
     2107
     2108        if (DATA(packet->trace)->byteswapped) {
     2109                blocktype = byteswap32(hdr->blocktype);
     2110        } else {
     2111                blocktype = hdr->blocktype;
     2112        }
     2113
     2114        /* Skip x bytes to the options depending on what kind of packet this is */
     2115        if (blocktype == PCAPNG_SECTION_TYPE) { ptr += sizeof(pcapng_sec_t); }
     2116        else if (blocktype == PCAPNG_INTERFACE_TYPE) { ptr += sizeof(pcapng_int_t); }
     2117        else if (blocktype == PCAPNG_OLD_PACKET_TYPE) { ptr += sizeof(pcapng_opkt_t); }
     2118        else if (blocktype == PCAPNG_NAME_RESOLUTION_TYPE) { ptr += sizeof(pcapng_epkt_t); }
     2119        else if (blocktype == PCAPNG_INTERFACE_STATS_TYPE) { ptr += sizeof(pcapng_stats_t); }
     2120        else if (blocktype == PCAPNG_ENHANCED_PACKET_TYPE) {
     2121                /* jump over the the enchanced packet header and data to the options */
     2122                pcapng_epkt_t *epkthdr = (pcapng_epkt_t *)ptr;
     2123                uint32_t seclen;
     2124                if (DATA(packet->trace)->byteswapped) {
     2125                        seclen = byteswap32(epkthdr->caplen);
     2126                } else {
     2127                        seclen = epkthdr->caplen;
     2128                }
     2129                if ((seclen % 4) != 0) {
     2130                        ptr += seclen + (4 -(seclen % 4)) + sizeof(pcapng_secrets_t);
     2131                } else {
     2132                        ptr += seclen + sizeof(pcapng_secrets_t);
     2133                }
     2134        }
     2135        else if (blocktype == PCAPNG_DECRYPTION_SECRETS_TYPE) {
     2136                /* jump over the decryption secrets header and data to the options */
     2137                pcapng_secrets_t *sechdr = (pcapng_secrets_t *)ptr;
     2138                uint32_t seclen;
     2139                if (DATA(packet->trace)->byteswapped) {
     2140                        seclen = byteswap32(sechdr->secrets_len);
     2141                } else {
     2142                        seclen = sechdr->secrets_len;
     2143                }
     2144                if ((seclen % 4) != 0) {
     2145                        ptr += seclen + (4 -(seclen % 4)) + sizeof(pcapng_secrets_t);
     2146                } else {
     2147                        ptr += seclen + sizeof(pcapng_secrets_t);
     2148                }
     2149        }
     2150        else { return NULL; }
     2151
     2152        return ptr;
     2153}
     2154
     2155void *pcapng_get_meta_section(libtrace_packet_t *packet, uint32_t section) {
     2156
     2157        struct pcapng_peeker *hdr;
     2158        uint32_t remaining;
     2159        void *ptr;
     2160        uint32_t blocktype;
     2161        uint16_t optcode;
     2162        uint16_t len;
     2163        uint16_t tmp;
     2164
     2165        if (packet->buffer == NULL) { return NULL; }
     2166
     2167        hdr = (struct pcapng_peeker *)packet->buffer;
     2168        ptr = pcapng_jump_to_options(packet);
     2169
     2170        if (DATA(packet->trace)->byteswapped) {
     2171                blocktype = byteswap32(hdr->blocktype);
     2172                remaining = byteswap32(hdr->blocklen);
     2173        } else {
     2174                blocktype = hdr->blocktype;
     2175                remaining = hdr->blocklen;
     2176        }
     2177
     2178        /* If the data we want is not within this blocktype */
     2179        if (blocktype != section) {
     2180                return NULL;
     2181        }
     2182
     2183        /* update remaining to account for header and any payload */
     2184        remaining -= (ptr - packet->buffer);
     2185
     2186        struct pcapng_optheader *opthdr = ptr;
     2187        if (DATA(packet->trace)->byteswapped) {
     2188                optcode = byteswap16(opthdr->optcode);
     2189                len  = byteswap16(opthdr->optlen);
     2190        } else {
     2191                optcode = opthdr->optcode;
     2192                len = opthdr->optlen;
     2193        }
     2194
     2195        /* setup structure to hold the result */
     2196        libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
     2197        result->section = section;
     2198        result->num = 0;
     2199
     2200        while (optcode != PCAPNG_OPTION_END && remaining > sizeof(struct pcapng_optheader)) {
     2201
     2202                result->num += 1;
     2203                if (result->num == 1) {
     2204                        result->items = malloc(sizeof(libtrace_meta_item_t));
     2205                } else {
     2206                        result->items = realloc(result->items,
     2207                                result->num*sizeof(libtrace_meta_item_t));
     2208                }
     2209                result->items[result->num-1].option = optcode;
     2210                result->items[result->num-1].len = len;
     2211                result->items[result->num-1].data_type = 0;
     2212                result->items[result->num-1].data = calloc(1, len);
     2213                memcpy(result->items[result->num-1].data,
     2214                        ptr+sizeof(struct pcapng_optheader), len);
     2215
     2216                /* work out any padding */
     2217                if ((len % 4) != 0) {
     2218                        tmp = len + (4 - (len % 4)) + sizeof(struct pcapng_optheader);
     2219                } else {
     2220                        tmp = len + sizeof(struct pcapng_optheader);
     2221                }
     2222                ptr += tmp;
     2223                remaining -= tmp;
     2224
     2225                /* get the next option */
     2226                opthdr = (struct pcapng_optheader *)ptr;
     2227                if (DATA(packet->trace)->byteswapped) {
     2228                        optcode = byteswap16(opthdr->optcode);
     2229                        len = byteswap16(opthdr->optlen);
     2230                } else {
     2231                        optcode = opthdr->optcode;
     2232                        len = opthdr->optlen;
     2233                }
     2234        }
     2235
     2236        /* if any data was found result->num will be greater than 0 */
     2237        if (result->num > 0) {
     2238                return (void *)result;
     2239        } else {
     2240                free(result);
     2241                return NULL;
     2242        }
     2243
     2244}
     2245
     2246void *pcapng_get_meta_section_option(libtrace_packet_t *packet, uint32_t section,
     2247        uint16_t option) {
    21042248
    21052249        struct pcapng_peeker *hdr;
     
    21072251        uint32_t blocktype;
    21082252        uint16_t optcode;
    2109         int remaining;
     2253        uint32_t remaining;
     2254        uint16_t len;
     2255        uint16_t tmp;
    21102256
    21112257        if (packet->buffer == NULL) { return NULL; }
    21122258
    21132259        hdr = (struct pcapng_peeker *)packet->buffer;
    2114         ptr = packet->buffer;
     2260        ptr = pcapng_jump_to_options(packet);
    21152261
    21162262        if (DATA(packet->trace)->byteswapped) {
     
    21222268        }
    21232269
    2124         /* If the data we want is not within this blocktype just return */
    2125         if (blocktype != section_type) {
     2270        /* If the data we want is not within this blocktype */
     2271        if (blocktype != section) {
    21262272                return NULL;
    21272273        }
    2128 
    2129         /* Skip x bytes to the options depending on what kind of packet this is */
    2130         if (section_type == PCAPNG_SECTION_TYPE) { ptr += sizeof(pcapng_sec_t); }
    2131         else if (section_type == PCAPNG_INTERFACE_TYPE) { ptr += sizeof(pcapng_int_t); }
    2132         else if (section_type == PCAPNG_OLD_PACKET_TYPE) { ptr += sizeof(pcapng_opkt_t); }
    2133         else if (section_type == PCAPNG_NAME_RESOLUTION_TYPE) { ptr += sizeof(pcapng_epkt_t); }
    2134         else if (section_type == PCAPNG_INTERFACE_STATS_TYPE) { ptr += sizeof(pcapng_stats_t); }
    2135         else if (section_type == PCAPNG_ENHANCED_PACKET_TYPE) {
    2136                 /* jump over the the enchanced packet header and data to the options */
    2137                 pcapng_epkt_t *epkthdr = (pcapng_epkt_t *)ptr;
    2138                 uint32_t seclen;
    2139                 if (DATA(packet->trace)->byteswapped) {
    2140                         seclen = byteswap32(epkthdr->caplen);
    2141                 } else {
    2142                         seclen = epkthdr->caplen;
    2143                 }
    2144                 if ((seclen % 4) != 0) {
    2145                         ptr += seclen + (4 -(seclen % 4)) + sizeof(pcapng_secrets_t);
    2146                 } else {
    2147                         ptr += seclen + sizeof(pcapng_secrets_t);
    2148                 }
    2149         }
    2150         else if (section_type == PCAPNG_DECRYPTION_SECRETS_TYPE) {
    2151                 /* jump over the decryption secrets header and data to the options */
    2152                 pcapng_secrets_t *sechdr = (pcapng_secrets_t *)ptr;
    2153                 uint32_t seclen;
    2154                 if (DATA(packet->trace)->byteswapped) {
    2155                         seclen = byteswap32(sechdr->secrets_len);
    2156                 } else {
    2157                         seclen = sechdr->secrets_len;
    2158                 }
    2159                 if ((seclen % 4) != 0) {
    2160                         ptr += seclen + (4 -(seclen % 4)) + sizeof(pcapng_secrets_t);
    2161                 } else {
    2162                         ptr += seclen + sizeof(pcapng_secrets_t);
    2163                 }
    2164         }
    2165         else { return NULL; }
    21662274
    21672275        /* update remaining to account for header and any payload */
     
    21722280        if (DATA(packet->trace)->byteswapped) {
    21732281                optcode = byteswap16(opthdr->optcode);
     2282                len  = byteswap16(opthdr->optlen);
    21742283        } else {
    21752284                optcode = opthdr->optcode;
    2176         }
    2177         while ((optcode != section) && (optcode != PCAPNG_OPTION_END) &&
    2178                 (remaining > 0)) {
    2179 
    2180                 uint16_t len;
    2181 
    2182                 if (DATA(packet->trace)->byteswapped) {
    2183                         len = byteswap16(opthdr->optlen);
    2184                 } else {
    2185                         len = opthdr->optlen;
    2186                 }
     2285                len = opthdr->optlen;
     2286        }
     2287
     2288        /* Iterate over the options till we reach the end of the options or we find
     2289         * the option we want */
     2290        while ((optcode != option) && (optcode != PCAPNG_OPTION_END) &&
     2291                (remaining > sizeof(struct pcapng_optheader))) {
    21872292
    21882293                /* work out any padding */
    21892294                if ((len % 4) != 0) {
    2190                         ptr += len + (4 - (len % 4)) + sizeof(struct pcapng_optheader);
     2295                        tmp = len + (4 - (len % 4)) + sizeof(struct pcapng_optheader);
    21912296                } else {
    2192                         ptr += len + sizeof(struct pcapng_optheader);
    2193                 }
     2297                        tmp = len + sizeof(struct pcapng_optheader);
     2298                }
     2299                ptr += tmp;
     2300                remaining -= tmp;
    21942301
    21952302                /* get the next option */
     
    21972304                if (DATA(packet->trace)->byteswapped) {
    21982305                        optcode = byteswap16(opthdr->optcode);
     2306                        len = byteswap16(opthdr->optlen);
    21992307                } else {
    22002308                        optcode = opthdr->optcode;
    2201                 }
    2202 
    2203                 /* update remaining */
    2204                 remaining -= (ptr-packet->buffer);
    2205 
     2309                        len = opthdr->optlen;
     2310                }
    22062311        }
    22072312
    22082313        /* either a option was found or they ran out */
    2209         if (opthdr->optcode == section) {
    2210                 return ptr;
     2314        if (opthdr->optcode == option) {
     2315
     2316                libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
     2317                result->section = section;
     2318                result->num = 1;
     2319
     2320                result->items = malloc(sizeof(libtrace_meta_item_t));
     2321                result->items->option = option;
     2322                result->items->len = len;
     2323                result->items->data_type = 0;
     2324                result->items->data = calloc(1, len);
     2325
     2326                memcpy(result->items->data, ptr+sizeof(struct pcapng_optheader), len);
     2327
     2328                return (void *)result;
    22112329        } else {
    22122330                return NULL;
     
    22512369        pcapng_get_timespec,            /* get_timespec */
    22522370        NULL,                           /* get_seconds */
    2253         pcapng_get_meta_data,           /* get_meta_data */
     2371        pcapng_get_meta_section,        /* get_meta_section */
     2372        pcapng_get_meta_section_option, /* get_meta_section_option */
    22542373        NULL,                           /* seek_erf */
    22552374        NULL,                           /* seek_timeval */
  • lib/format_pktmeta.c

    r629b19b ref5ba20  
    2525/* API functions to retrieve interface related packet data */
    2626
    27 /* Reads the interface name for a packet
    28  *
    29  * @params libtrace_packet_t packet
    30  * @returns A pointer to a NULL terminated string containing the interface name or NULL
    31  */
    32 char *trace_get_interface_name(libtrace_packet_t *packet) {
     27/* Destroy libtrace_meta_t structure
     28 *
     29 * @params libtrace_meta_t structure
     30 * returns 1 on success, -1 on failure
     31 */
     32int trace_destroy_meta(libtrace_meta_t *result) {
     33        int i;
     34        if (!result) { return -1; }
     35
     36        for (i=0;i<result->num;i++) {
     37                if(result->items[i].data) {
     38                        free(result->items[i].data);
     39                }
     40        }
     41        if (result->items) {
     42                free(result->items);
     43        }
     44        if (result) {
     45                free(result);
     46        }
     47
     48        return 1;
     49}
     50
     51/* Get the interface name/s
     52 * Must be destroyed with trace_destroy_meta()
     53 *
     54 * @params libtrace_packet_t meta packet
     55 * @returns Pointer to libtrace_meta_t structure or NULL
     56 */
     57libtrace_meta_t *trace_get_interface_name(libtrace_packet_t *packet) {
    3358        if (trace_meta_check_input(packet, "trace_get_interface_name()")<0) {
    3459                return NULL;
    3560        }
    3661
    37         void *ptr = NULL;
    38 
    39         /* cleanup any old results */
    40         if (packet->meta.interface_name != NULL) {
    41                 free(packet->meta.interface_name);
    42                 packet->meta.interface_name = NULL;
    43         }
    44 
    4562        /* get the result */
    4663        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    47                 ptr = packet->trace->format->get_meta_data(packet,
     64                return packet->trace->format->get_meta_section_item(packet,
    4865                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_NAME);
    4966        }
    5067        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    51                 ptr = packet->trace->format->get_meta_data(packet,
     68                return packet->trace->format->get_meta_section_item(packet,
    5269                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_NAME);
    5370        }
    5471
    55         /* If a result was found */
    56         if (ptr != NULL) {
    57                 libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
    58 
    59                 /* store this result against the packet itself */
    60                 packet->meta.interface_name = malloc(ntohs(result->len)+1);
    61                 /* add NULL terminator to string */
    62                 packet->meta.interface_name[ntohs(result->len)] = '\0';
    63                 /* copy result over */
    64                 memcpy(packet->meta.interface_name, ptr+sizeof(libtrace_meta_result_t),
    65                         ntohs(result->len));
    66 
    67                 return packet->meta.interface_name;
    68         }
    69 
    70         return NULL;
    71 }
    72 
    73 /* Gets the interface MAC address from a meta packet
    74  *
    75  * @params libtrace_packet_t packet
    76  * @returns A pointer to a MAC address within the packet or NULL
    77  */
    78 void *trace_get_interface_mac(libtrace_packet_t *packet) {
     72        return NULL;
     73}
     74
     75/* Get the interface MAC address/s
     76 * Must be destroyed with trace_destroy_meta()
     77 *
     78 * @params libtrace_packet_t meta packet
     79 * @returns Pointer to libtrace_meta_t structure or NULL
     80 */
     81libtrace_meta_t *trace_get_interface_mac(libtrace_packet_t *packet) {
    7982        if (trace_meta_check_input(packet, "trace_get_interface_mac()")<0) {
    8083                return NULL;
    8184        }
    8285
    83         void *ptr = NULL;
    84 
    85         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    86                 ptr = packet->trace->format->get_meta_data(packet,
     86        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     87                return packet->trace->format->get_meta_section_item(packet,
    8788                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_MAC);
    8889        }
    8990        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    90                 ptr = packet->trace->format->get_meta_data(packet,
     91                return packet->trace->format->get_meta_section_item(packet,
    9192                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_MAC);
    9293        }
    9394
    94         if (ptr != NULL) {
    95                 packet->meta.interface_mac = ptr+sizeof(libtrace_meta_result_t);
    96                 return packet->meta.interface_mac;
    97         }
    98 
    99         return NULL;
    100 }
    101 
    102 /* Gets the interface speed from a meta packet
    103  *
    104  * @params libtrace_packet_t packet
    105  * @returns A pointer to the uint64_t interface speed within the packet or NULL
    106  */
    107 uint64_t *trace_get_interface_speed(libtrace_packet_t *packet) {
     95        return NULL;
     96}
     97
     98/* Get the interface speed/s from a meta packet
     99 * Must be destroyed with trace_destroy_meta()
     100 *
     101 * @params libtrace_packet_t packet
     102 * @returns Pointer to libtrace_meta_t structure or NULL
     103 */
     104libtrace_meta_t *trace_get_interface_speed(libtrace_packet_t *packet) {
    108105        if (trace_meta_check_input(packet, "trace_get_interface_speed()")<0) {
    109106                return NULL;
    110107        }
    111108
    112         void *ptr = NULL;
    113 
    114         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    115                 ptr = packet->trace->format->get_meta_data(packet,
     109        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     110                return packet->trace->format->get_meta_section_item(packet,
    116111                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_SPEED);
    117112        }
    118113        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    119                 ptr = packet->trace->format->get_meta_data(packet,
     114                return packet->trace->format->get_meta_section_item(packet,
    120115                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_SPEED);
    121116        }
    122117
    123         if (ptr != NULL) {
    124                 uint64_t *intspeed = (uint64_t *)(ptr+sizeof(libtrace_meta_result_t));
    125                 packet->meta.interface_speed = *intspeed;
    126                 return &packet->meta.interface_speed;
    127         }
    128 
    129         return NULL;
    130 }
    131 
    132 /* Gets the interface ipv4 address from a meta packet
    133  *
    134  * @params libtrace_packet_t packet
    135  * @returns A pointer to the IP4 address field within the packet or NULL
    136  */
    137 uint32_t *trace_get_interface_ip4(libtrace_packet_t *packet) {
     118        return NULL;
     119}
     120
     121/* Get the interface ipv4 address/s
     122 * Must be destroyed with trace_destroy_meta()
     123 *
     124 * @params libtrace_packet_t meta packet
     125 * @returns Pointer to libtrace_meta_t structure or NULL
     126 */
     127libtrace_meta_t *trace_get_interface_ip4(libtrace_packet_t *packet) {
    138128        if (trace_meta_check_input(packet, "trace_get_interface_ip4()")<0) {
    139129                return NULL;
    140130        }
    141131
    142         void *ptr = NULL;
    143 
    144         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    145                 ptr = packet->trace->format->get_meta_data(packet,
     132        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     133                return packet->trace->format->get_meta_section_item(packet,
    146134                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
    147135        }
    148136        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    149                 ptr = packet->trace->format->get_meta_data(packet,
     137                return packet->trace->format->get_meta_section_item(packet,
    150138                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_IP4);
    151139        }
    152140
    153         if (ptr != NULL) {
    154                 uint32_t *intip4 = (uint32_t *)(ptr+sizeof(libtrace_meta_result_t));
    155                 packet->meta.interface_ipv4 = *intip4;
    156                 return &packet->meta.interface_ipv4;
    157         }
    158 
    159         return NULL;
    160 }
    161 uint32_t *trace_get_interface_ipv4(libtrace_packet_t *packet) {
     141        return NULL;
     142}
     143libtrace_meta_t *trace_get_interface_ipv4(libtrace_packet_t *packet) {
    162144        return trace_get_interface_ip4(packet);
    163145}
    164146
    165 void *trace_get_interface_ip6(libtrace_packet_t *packet) {
     147/* Get the interface ipv6 address/s
     148 * Must be destroyed with trace_destroy_meta()
     149 *
     150 * @params libtrace_packet_t meta packet
     151 * @returns Pointer to libtrace_meta_t structure or NULL
     152 */
     153libtrace_meta_t *trace_get_interface_ip6(libtrace_packet_t *packet) {
    166154        if (trace_meta_check_input(packet, "trace_get_interface_ip6()")<0) {
    167155                return NULL;
    168156        }
    169157
    170         void *ptr = NULL;
    171 
    172         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    173                 ptr = packet->trace->format->get_meta_data(packet,
     158        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     159                return packet->trace->format->get_meta_section_item(packet,
    174160                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
    175161        }
    176162        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    177                 ptr = packet->trace->format->get_meta_data(packet,
     163                return packet->trace->format->get_meta_section_item(packet,
    178164                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_IP4);
    179165        }
    180166
    181         if (ptr != NULL) {
    182                 packet->meta.interface_ipv6 = ptr+sizeof(libtrace_meta_result_t);
    183                 return packet->meta.interface_ipv6;
    184         }
    185 
    186         return NULL;
    187 }
    188 void *trace_get_interface_ipv6(libtrace_packet_t *packet) {
     167        return NULL;
     168}
     169libtrace_meta_t *trace_get_interface_ipv6(libtrace_packet_t *packet) {
    189170        return trace_get_interface_ip6(packet);
    190171}
    191172
    192 /* Gets the interface description for a packet
    193  *
    194  * @params libtrace_packet_t packet
    195  * @returns A pointer to a NULL terminated interface description string or NULL
    196  */
    197 char *trace_get_interface_description(libtrace_packet_t *packet) {
     173/* Get the interface description/s
     174 * Must be destroyed with trace_destroy_meta()
     175 *
     176 * @params libtrace_packet_t meta packet
     177 * @returns Pointer to libtrace_meta_t structure or NULL
     178 */
     179libtrace_meta_t *trace_get_interface_description(libtrace_packet_t *packet) {
    198180        if (trace_meta_check_input(packet, "trace_get_interface_description()")<0) {
    199181                return NULL;
    200182        }
    201183
    202         if (packet->meta.interface_description != NULL) {
    203                 free(packet->meta.interface_description);
    204                 packet->meta.interface_description = NULL;
    205         }
    206 
    207         void *ptr = NULL;
    208 
    209         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    210                 ptr = packet->trace->format->get_meta_data(packet,
     184        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     185                return packet->trace->format->get_meta_section_item(packet,
    211186                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_DESCR);
    212187        }
    213188        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    214                 ptr = packet->trace->format->get_meta_data(packet,
     189                return packet->trace->format->get_meta_section_item(packet,
    215190                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_DESCR);
    216191        }
    217192
    218         if (ptr != NULL) {
    219                 libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
    220                 packet->meta.interface_description = malloc(ntohs(result->len)+1);
    221                 packet->meta.interface_description[ntohs(result->len)] = '\0';
    222                 memcpy(packet->meta.interface_description, ptr+sizeof(libtrace_meta_result_t),
    223                         ntohs(result->len));
    224 
    225                 return packet->meta.interface_description;
    226         }
    227 
    228         return NULL;
    229 }
    230 
    231 /* Gets the interface number for the packet
    232  *
    233  * @params libtrace_packet_t packet
    234  * @returns A void pointer to the beginning of a uint32_t interface number;
    235  */
    236 uint32_t *trace_get_interface_num(libtrace_packet_t *packet) {
     193        return NULL;
     194}
     195
     196/* Get the interface number/s
     197 * Must be destroyed with trace_destroy_meta()
     198 *
     199 * @params libtrace_packet_t meta packet
     200 * @returns Pointer to libtrace_meta_t structure or NULL
     201 */
     202libtrace_meta_t *trace_get_interface_num(libtrace_packet_t *packet) {
    237203        if (trace_meta_check_input(packet, "trace_get_interface_num()")<0) {
    238204                return NULL;
    239205        }
    240206
    241         void *ptr = NULL;
    242 
    243         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    244                 ptr = packet->trace->format->get_meta_data(packet,
     207        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     208                return packet->trace->format->get_meta_section_item(packet,
    245209                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_NUM);
    246210        }
    247211        /* Note: pcapng doesnt provide this */
    248212
    249         if (ptr != NULL) {
    250                 uint32_t *intnum = (uint32_t *)(ptr+sizeof(libtrace_meta_result_t));
    251                 packet->meta.interface_num = *intnum;
    252                 return &packet->meta.interface_num;
    253         }
    254 
    255         return NULL;
    256 }
    257 
    258 /* Gets the host OS from a packets originating interface
    259  *
    260  * @params libtrace_packet_t packet
    261  * @returns A pointer to a NULL terminated string or NULL
    262  */
    263 char *trace_get_host_os(libtrace_packet_t *packet) {
     213        return NULL;
     214}
     215
     216/* Get the host OS
     217 * Must be destroyed with trace_destroy_meta()
     218 *
     219 * @params libtrace_packet_t meta packet
     220 * @returns Pointer to libtrace_meta_t structure or NULL
     221 */
     222libtrace_meta_t *trace_get_host_os(libtrace_packet_t *packet) {
    264223        if (trace_meta_check_input(packet, "trace_get_host_os()")<0) {
    265224                return NULL;
    266225        }
    267226
    268         if (packet->meta.host_os != NULL) {
    269                 free(packet->meta.host_os);
    270                 packet->meta.host_os = NULL;
    271         }
    272 
    273         void *ptr = NULL;
    274 
    275         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    276                 ptr = packet->trace->format->get_meta_data(packet,
     227        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     228                return packet->trace->format->get_meta_section_item(packet,
    277229                        ERF_PROV_SECTION_HOST, ERF_PROV_OS);
    278230        }
    279231        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    280                 ptr = packet->trace->format->get_meta_data(packet,
     232                return packet->trace->format->get_meta_section_item(packet,
    281233                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_OS);
    282234        }
    283235
    284         if (ptr != NULL) {
    285                 libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
    286                 packet->meta.host_os = malloc(ntohs(result->len)+1);
    287                 packet->meta.host_os[ntohs(result->len)] = '\0';
    288                 memcpy(packet->meta.host_os, ptr+sizeof(libtrace_meta_result_t),
    289                         ntohs(result->len));
    290 
    291                 return packet->meta.host_os;
    292         }
    293 
    294         return NULL;
    295 }
    296 
    297 /* Gets the frame check sequence length from a packets originating interface
    298  *
    299  * @params libtrace_packet_t packet
    300  * @returns A uint32_t pointer containing the fcslen or NULL
    301  */
    302 uint32_t *trace_get_interface_frame_check_sequence_length(libtrace_packet_t *packet) {
     236        return NULL;
     237}
     238
     239/* Get the frame check sequence length
     240 * Must be destroyed with trace_destroy_meta()
     241 *
     242 * @params libtrace_packet_t meta packet
     243 * @returns Pointer to libtrace_meta_t structure or NULL
     244 */
     245libtrace_meta_t *trace_get_interface_frame_check_sequence_length(libtrace_packet_t *packet) {
    303246        if (trace_meta_check_input(packet, "trace_get_interface_frame_check_sequence_length()")<0) {
    304247                return NULL;
    305248        }
    306249
    307         void *ptr = NULL;
    308 
    309         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    310                 ptr = packet->trace->format->get_meta_data(packet,
     250        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     251                return packet->trace->format->get_meta_section_item(packet,
    311252                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_FCS_LEN);
    312253        }
    313254        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    314                 ptr = packet->trace->format->get_meta_data(packet,
     255                return packet->trace->format->get_meta_section_item(packet,
    315256                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_FCSLEN);
    316257        }
    317258
    318         if (ptr != NULL) {
    319 
    320                 if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    321                         uint32_t *val = (uint32_t *)(ptr+sizeof(libtrace_meta_result_t));
    322                         packet->meta.interface_fcslen = *val;
    323                 } else if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    324                         uint8_t *val = (uint8_t *)(ptr+sizeof(libtrace_meta_result_t));
    325                         packet->meta.interface_fcslen = *val;
    326                 }
    327                 return &packet->meta.interface_fcslen;
    328         }
    329 
    330         return NULL;
    331 }
    332 
    333 char *trace_get_interface_hardware_description(libtrace_packet_t *packet) {
     259        return NULL;
     260}
     261
     262/* Get the hardware description
     263 * Must be destroyed with trace_destroy_meta()
     264 *
     265 * @params libtrace_packet_t meta packet
     266 * @returns Pointer to libtrace_meta_t structure or NULL
     267 */
     268libtrace_meta_t *trace_get_interface_hardware_description(libtrace_packet_t *packet) {
    334269        if (trace_meta_check_input(packet, "trace_get_interface_hardware_description()")<0) {
    335270                return NULL;
    336271        }
    337272
    338         if (packet->meta.interface_hardware_desc != NULL) {
    339                 free(packet->meta.interface_hardware_desc);
    340                 packet->meta.interface_hardware_desc = NULL;
    341         }
    342 
    343         void *ptr = NULL;
    344 
    345273        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    346                 ptr = packet->trace->format->get_meta_data(packet,
     274                return packet->trace->format->get_meta_section_item(packet,
    347275                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_HARDWARE);
    348276        }
    349277        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    350                 ptr = packet->trace->format->get_meta_data(packet,
     278                return packet->trace->format->get_meta_section_item(packet,
    351279                        ERF_PROV_SECTION_MODULE, ERF_PROV_MODEL);
    352280        }
    353281
    354         if (ptr != NULL) {
    355                 libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
    356                 packet->meta.interface_hardware_desc = malloc(ntohs(result->len)+1);
    357                 packet->meta.interface_hardware_desc[ntohs(result->len)] = '\0';
    358                 memcpy(packet->meta.interface_hardware_desc, ptr+sizeof(libtrace_meta_result_t),
    359                         ntohs(result->len));
    360 
    361                 return packet->meta.interface_hardware_desc;
    362         }
    363 
    364         return NULL;
    365 }
    366 
    367 char *trace_get_interface_comment(libtrace_packet_t *packet) {
     282        return NULL;
     283}
     284
     285/* Get any interface comments for a meta packet
     286 * Must be destroyed with trace_destroy_meta()
     287 *
     288 * @params libtrace_packet_t packet
     289 * @returns Pointer to libtrace_meta_t structure or NULL
     290 */
     291libtrace_meta_t *trace_get_interface_comment(libtrace_packet_t *packet) {
    368292        if (trace_meta_check_input(packet, "trace_get_interface_comment()")<0) {
    369293                return NULL;
    370294        }
    371295
    372         if (packet->meta.interface_comment != NULL) {
    373                 free(packet->meta.interface_comment);
    374                 packet->meta.interface_comment = NULL;
    375         }
    376 
    377         void *ptr = NULL;
    378 
    379         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    380                 ptr = packet->trace->format->get_meta_data(packet,
     296        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     297                return packet->trace->format->get_meta_section_item(packet,
    381298                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_COMMENT);
    382299        }
    383300        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    384                 ptr = packet->trace->format->get_meta_data(packet,
     301                return packet->trace->format->get_meta_section_item(packet,
    385302                        PCAPNG_INTERFACE_TYPE, PCAPNG_OPTION_COMMENT);
    386303        }
    387304
    388         if (ptr != NULL) {
    389                 libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
    390                 packet->meta.interface_comment = malloc(ntohs(result->len)+1);
    391                 packet->meta.interface_comment[ntohs(result->len)] = '\0';
    392                 memcpy(packet->meta.interface_comment, ptr+sizeof(libtrace_meta_result_t),
    393                         ntohs(result->len));
    394 
    395                 return packet->meta.interface_comment;
    396         }
    397 
    398         return NULL;
    399 }
    400 
    401 char *trace_get_capture_application(libtrace_packet_t *packet) {
     305        return NULL;
     306}
     307
     308/* Get the capture application for a meta packet
     309 * Must be destroyed with trace_destroy_meta()
     310 *
     311 * @params libtrace_packet_t packet
     312 * @returns Pointer to libtrace_meta_t structure or NULL
     313 */
     314libtrace_meta_t *trace_get_capture_application(libtrace_packet_t *packet) {
    402315        if (trace_meta_check_input(packet, "trace_get_interface_comment()")<0) {
    403316                return NULL;
    404317        }
    405318
    406         if (packet->meta.capture_application != NULL) {
    407                 free(packet->meta.capture_application);
    408                 packet->meta.capture_application = NULL;
    409         }
    410 
    411         void *ptr = NULL;
    412 
    413         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    414                 ptr = packet->trace->format->get_meta_data(packet,
     319        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     320                return packet->trace->format->get_meta_section_item(packet,
    415321                        ERF_PROV_SECTION_CAPTURE, ERF_PROV_APP_NAME);
    416322        }
    417323        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    418                 ptr = packet->trace->format->get_meta_data(packet,
     324                return packet->trace->format->get_meta_section_item(packet,
    419325                        PCAPNG_SECTION_TYPE, PCAPNG_META_SHB_USERAPPL);
    420326        }
    421327
    422         if (ptr != NULL) {
    423                 libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
    424                 packet->meta.capture_application = malloc(ntohs(result->len)+1);
    425                 packet->meta.capture_application[ntohs(result->len)] = '\0';
    426                 memcpy(packet->meta.capture_application, ptr+sizeof(libtrace_meta_result_t),
    427                         ntohs(result->len));
    428 
    429                 return packet->meta.capture_application;
    430         }
    431 
    432328        return NULL;
    433329}
    434330
    435 
     331/* Get meta section option from a meta packet
     332 * Must be destroyed with trace_destroy_meta()
     333 *
     334 * @params libtrace_packet_t packet
     335 * @params Section code
     336 * @params Option code
     337 * @returns Pointer to libtrace_meta_t structure or NULL
     338 */
     339libtrace_meta_t *trace_get_section_option(libtrace_packet_t *packet, uint32_t section_code,
     340        uint16_t option_code) {
     341
     342        if (trace_meta_check_input(packet, "trace_get_custom_meta()")<0) {
     343                return NULL;
     344        }
     345
     346        return packet->trace->format->get_meta_section_item(packet,
     347                section_code, option_code);
     348}
     349
     350/* Get a section from a meta packet
     351 * Must be destroyed with trace_destroy_meta()
     352 *
     353 * @params libtrace_packet_t packet
     354 * @params Section code
     355 * @returns Pointer to libtrace_meta_t structure or NULL
     356 */
     357libtrace_meta_t *trace_get_section(libtrace_packet_t *packet, uint32_t section_code) {
     358        if (trace_meta_check_input(packet, "trace_get_section()")<0) {
     359                return NULL;
     360        }
     361
     362        return packet->trace->format->get_meta_section(packet, section_code);
     363}
  • lib/format_rt.c

    r977e0db ref5ba20  
    863863        NULL,                           /* get_timespec */
    864864        NULL,                           /* get_seconds */
    865         NULL,                           /* get_meta_data */
     865        NULL,                           /* get_meta_section */
     866        NULL,                           /* get_meta_section_item */
    866867        NULL,                           /* seek_erf */
    867868        NULL,                           /* seek_timeval */
  • lib/format_tsh.c

    r977e0db ref5ba20  
    252252        NULL,                           /* get_timespec */
    253253        NULL,                           /* get_seconds */
    254         NULL,                           /* get_meta_data */
     254        NULL,                           /* get_meta_section */
     255        NULL,                           /* get_meta_section_item */
    255256        NULL,                           /* seek_erf */
    256257        NULL,                           /* seek_timeval */
     
    303304        NULL,                           /* get_timespec */
    304305        NULL,                           /* get_seconds */
    305         NULL,                           /* get_meta_data */
     306        NULL,                           /* get_meta_section */
     307        NULL,                           /* get_meta_section_item */
    306308        NULL,                           /* seek_erf */
    307309        NULL,                           /* seek_timeval */
  • lib/libtrace.h.in

    re7132d6 ref5ba20  
    586586} libtrace_meta_result_t;
    587587
     588typedef struct libtrace_meta_section_item {
     589        uint16_t option;
     590        uint16_t len;
     591        uint8_t data_type;
     592        void *data;
     593} libtrace_meta_item_t;
     594
     595typedef struct libtrace_meta_section {
     596        uint16_t section;
     597        uint16_t num;
     598        libtrace_meta_item_t *items;
     599} libtrace_meta_t;
     600
    588601typedef struct libtrace_meta {
    589602        char *interface_name;           /**< Interface name packet was captured on */
     
    599612        char *interface_comment;        /**< Interface comment */
    600613        char *capture_application;      /**< Name of the capturing application */
    601 } libtrace_meta_t;
     614} libtrace_meta_tt;
    602615
    603616typedef struct libtrace_packet_cache {
     
    638651        int which_trace_start;          /**< Used to match packet to a started instance of the parent trace */
    639652
    640         libtrace_meta_t meta;           /**< Meta data for the packet */
     653        libtrace_meta_tt meta;           /**< Meta data for the packet */
    641654} libtrace_packet_t;
    642655
     
    37203733#endif /* #ifdef __cplusplus */
    37213734
    3722 char *trace_get_interface_name(libtrace_packet_t *packet);
    3723 void *trace_get_interface_mac(libtrace_packet_t *packet);
    3724 uint64_t *trace_get_interface_speed(libtrace_packet_t *packet);
    3725 uint32_t *trace_get_interface_ip4(libtrace_packet_t *packet);
    3726 uint32_t *trace_get_interface_ipv4(libtrace_packet_t *packet);
    3727 void *trace_get_interface_ip6(libtrace_packet_t *packet);
    3728 void *trace_get_interface_ipv6(libtrace_packet_t *packet);
    3729 char *trace_get_interface_description(libtrace_packet_t *packet);
    3730 uint32_t *trace_get_interface_num(libtrace_packet_t *packet);
    3731 char *trace_get_host_os(libtrace_packet_t *packet);
    3732 uint32_t *trace_get_interface_frame_check_sequence_length(libtrace_packet_t *packet);
    3733 char *trace_get_interface_hardware_description(libtrace_packet_t *packet);
    3734 char *trace_get_interface_comment(libtrace_packet_t *packet);
    3735 char *trace_get_capture_application(libtrace_packet_t *packet);
     3735int trace_destroy_meta(libtrace_meta_t *result);
     3736libtrace_meta_t *trace_get_interface_name(libtrace_packet_t *packet);
     3737libtrace_meta_t *trace_get_interface_mac(libtrace_packet_t *packet);
     3738libtrace_meta_t *trace_get_interface_speed(libtrace_packet_t *packet);
     3739libtrace_meta_t *trace_get_interface_ip4(libtrace_packet_t *packet);
     3740libtrace_meta_t *trace_get_interface_ipv4(libtrace_packet_t *packet);
     3741libtrace_meta_t *trace_get_interface_ip6(libtrace_packet_t *packet);
     3742libtrace_meta_t *trace_get_interface_ipv6(libtrace_packet_t *packet);
     3743libtrace_meta_t *trace_get_interface_description(libtrace_packet_t *packet);
     3744libtrace_meta_t *trace_get_interface_num(libtrace_packet_t *packet);
     3745libtrace_meta_t *trace_get_host_os(libtrace_packet_t *packet);
     3746libtrace_meta_t *trace_get_interface_frame_check_sequence_length(libtrace_packet_t *packet);
     3747libtrace_meta_t *trace_get_interface_hardware_description(libtrace_packet_t *packet);
     3748libtrace_meta_t *trace_get_interface_comment(libtrace_packet_t *packet);
     3749libtrace_meta_t *trace_get_capture_application(libtrace_packet_t *packet);
     3750libtrace_meta_t *trace_get_section_item(libtrace_packet_t *packet, uint32_t section_code,
     3751        uint16_t option_code);
     3752libtrace_meta_t *trace_get_section(libtrace_packet_t *packet, uint32_t section_code);
    37363753
    37373754#endif /* LIBTRACE_H_ */
  • lib/libtrace_int.h

    r977e0db ref5ba20  
    725725        /**
    726726         */
    727         void *(*get_meta_data)(libtrace_packet_t *packet, uint32_t section_type,
    728                 uint16_t section);
     727        void *(*get_meta_section)(libtrace_packet_t *packet, uint32_t section_type);
     728        void *(*get_meta_section_item)(libtrace_packet_t *packet, uint32_t section_type,
     729                uint16_t section);
    729730
    730731        /** Moves the read pointer to a certain ERF timestamp within an input
Note: See TracChangeset for help on using the changeset viewer.