Ignore:
Timestamp:
01/16/19 13:52:38 (2 years 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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 */
Note: See TracChangeset for help on using the changeset viewer.