Changeset e7132d6


Ignore:
Timestamp:
01/14/19 15:37:27 (22 months ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
7aa03d9
Parents:
977e0db
Message:

improvements to meta-api

Location:
lib
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.h

    r977e0db re7132d6  
    4141#define ERF_PROV_NAME 12
    4242#define ERF_PROV_DESCR 13
     43#define ERF_PROV_APP_NAME 16
    4344#define ERF_PROV_HOSTNAME 18
    4445#define ERF_PROV_OS 17
  • lib/format_pcapng.c

    r977e0db re7132d6  
    9797} pcapng_stats_t;
    9898
     99typedef struct pcapng_decryption_secrets_header_t {
     100        uint32_t blocktype;
     101        uint32_t blocklen;
     102        uint32_t secrets_type;
     103        uint32_t secrets_len;
     104} pcapng_secrets_t;
     105
    99106typedef struct pcapng_custom_header_t {
    100107        uint32_t blocktype;
     
    21012108        uint16_t optcode;
    21022109
    2103         hdr = (struct pcapng_peeker *)packet->header;
    2104         ptr = packet->header;
     2110        hdr = (struct pcapng_peeker *)packet->buffer;
     2111        ptr = packet->buffer;
    21052112
    21062113        if (DATA(packet->trace)->byteswapped) {
     
    21102117        }
    21112118
    2112         /* Just return if data we want is not in this block */
     2119        /* If the data we want is not within this blocktype just return */
    21132120        if (blocktype != section_type) {
    21142121                return NULL;
     
    21172124        /* Skip x bytes to the options depending on what kind of packet this is */
    21182125        if (section_type == PCAPNG_SECTION_TYPE) { ptr += sizeof(pcapng_sec_t); }
    2119         if (section_type == PCAPNG_INTERFACE_TYPE) { ptr += sizeof(pcapng_int_t); }
    2120         if (section_type == PCAPNG_OLD_PACKET_TYPE) { ptr += sizeof(pcapng_opkt_t); }
    2121         if (section_type == PCAPNG_SIMPLE_PACKET_TYPE) { ptr += sizeof(pcapng_spkt_t); }
    2122         if (section_type == PCAPNG_NAME_RESOLUTION_TYPE) {
    2123                 /* look into this more */
    2124                 return NULL;
    2125         }
    2126         if (section_type == PCAPNG_INTERFACE_STATS_TYPE) { ptr += sizeof(pcapng_stats_t); }
    2127         if (section_type == PCAPNG_ENHANCED_PACKET_TYPE) { ptr += sizeof(pcapng_epkt_t); }
     2126        else if (section_type == PCAPNG_INTERFACE_TYPE) { ptr += sizeof(pcapng_int_t); }
     2127        else if (section_type == PCAPNG_OLD_PACKET_TYPE) { ptr += sizeof(pcapng_opkt_t); }
     2128        else if (section_type == PCAPNG_NAME_RESOLUTION_TYPE) { ptr += sizeof(pcapng_epkt_t); }
     2129        else if (section_type == PCAPNG_INTERFACE_STATS_TYPE) { ptr += sizeof(pcapng_stats_t); }
     2130        else if (section_type == PCAPNG_ENHANCED_PACKET_TYPE) {
     2131                /* jump over the the enchanced packet header and data to the options */
     2132                pcapng_epkt_t *epkthdr = (pcapng_epkt_t *)ptr;
     2133                uint32_t seclen;
     2134                if (DATA(packet->trace)->byteswapped) {
     2135                        seclen = byteswap32(epkthdr->caplen);
     2136                } else {
     2137                        seclen = epkthdr->caplen;
     2138                }
     2139                if ((seclen % 4) != 0) {
     2140                        ptr += seclen + (4 -(seclen % 4)) + sizeof(pcapng_secrets_t);
     2141                } else {
     2142                        ptr += seclen + sizeof(pcapng_secrets_t);
     2143                }
     2144        }
     2145        else if (section_type == PCAPNG_DECRYPTION_SECRETS_TYPE) {
     2146                /* jump over the decryption secrets header and data to the options */
     2147                pcapng_secrets_t *sechdr = (pcapng_secrets_t *)ptr;
     2148                uint32_t seclen;
     2149                if (DATA(packet->trace)->byteswapped) {
     2150                        seclen = byteswap32(sechdr->secrets_len);
     2151                } else {
     2152                        seclen = sechdr->secrets_len;
     2153                }
     2154                if ((seclen % 4) != 0) {
     2155                        ptr += seclen + (4 -(seclen % 4)) + sizeof(pcapng_secrets_t);
     2156                } else {
     2157                        ptr += seclen + sizeof(pcapng_secrets_t);
     2158                }
     2159        }
     2160        else { return NULL; }
    21282161
    21292162        /* Skip over the options till a match is found or they run out */
  • lib/format_pktmeta.c

    r977e0db re7132d6  
    99
    1010
     11/* Internal Meta functions */
     12
     13static int trace_meta_check_input(libtrace_packet_t *packet, char *input_func) {
     14        if (packet == NULL) {
     15                fprintf(stderr, "NULL packet passed into %s\n", input_func);
     16                return -1;
     17        }
     18        if (packet->trace == NULL) {
     19                fprintf(stderr, "Packet contains NULL trace in %s\n", input_func);
     20                return -1;
     21        }
     22        return 1;
     23}
     24
    1125/* API functions to retrieve interface related packet data */
    1226
    13 
    14 
    1527/* Reads the interface name for a packet
    1628 *
    1729 * @params libtrace_packet_t packet
    18  * @returns pointer to NULL terminated string containing the interface name
    19  */
    20 
     30 * @returns A pointer to a NULL terminated string containing the interface name or NULL
     31 */
    2132char *trace_get_interface_name(libtrace_packet_t *packet) {
    22         void *ptr = NULL;
    23 
    24         /* find the result if we havnt already */
     33        if (trace_meta_check_input(packet, "trace_get_interface_name()")<0) {
     34                return NULL;
     35        }
     36
     37        void *ptr = NULL;
     38
     39        /* cleanup any old results */
    2540        if (packet->meta.interface_name != NULL) {
    26                 return packet->meta.interface_name;
     41                free(packet->meta.interface_name);
     42                packet->meta.interface_name = NULL;
    2743        }
    2844
     
    5874 *
    5975 * @params libtrace_packet_t packet
    60  * @returns A pointer to a MAC address
    61  */
    62 char *trace_get_interface_mac(libtrace_packet_t *packet) {
    63         void *ptr = NULL;
    64 
    65         if (packet->meta.interface_mac != NULL) {
     76 * @returns A pointer to a MAC address within the packet or NULL
     77 */
     78void *trace_get_interface_mac(libtrace_packet_t *packet) {
     79        if (trace_meta_check_input(packet, "trace_get_interface_mac()")<0) {
     80                return NULL;
     81        }
     82
     83        void *ptr = NULL;
     84
     85        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     86                ptr = packet->trace->format->get_meta_data(packet,
     87                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_MAC);
     88        }
     89        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     90                ptr = packet->trace->format->get_meta_data(packet,
     91                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_MAC);
     92        }
     93
     94        if (ptr != NULL) {
     95                packet->meta.interface_mac = ptr+sizeof(libtrace_meta_result_t);
    6696                return packet->meta.interface_mac;
    6797        }
    6898
    69         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    70                 ptr = packet->trace->format->get_meta_data(packet,
    71                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_MAC);
    72         }
    73         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    74                 ptr = packet->trace->format->get_meta_data(packet,
    75                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_MAC);
    76         }
    77 
    78         if (ptr != NULL) {
    79                 /* allocate memory within the packet to store the result
    80                  * exclude any padding that could be included */
    81                 packet->meta.interface_mac = malloc(6);
    82                 /* copy result over */
    83                 memcpy(packet->meta.interface_mac, ptr+sizeof(libtrace_meta_result_t), 6);
    84 
    85                 return packet->meta.interface_mac;
    86         }
    87 
    8899        return NULL;
    89100}
     
    92103 *
    93104 * @params libtrace_packet_t packet
    94  * @returns uint64_t containing the interface speed or 0 if not found.
    95  */
    96 uint64_t trace_get_interface_speed(libtrace_packet_t *packet) {
    97         /* Get the result */
    98         void *ptr = packet->trace->format->get_meta_data(packet,
    99                 ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_SPEED);
    100 
    101         /* If a result was found */
    102         if (ptr != NULL) {
    103                 uint64_t *result = (uint64_t *)(ptr+sizeof(libtrace_meta_result_t));
    104                 packet->meta.interface_speed = *result;
    105 
    106                 return packet->meta.interface_speed;
    107         }
    108 
    109         return 0;
     105 * @returns A pointer to the uint64_t interface speed within the packet or NULL
     106 */
     107uint64_t *trace_get_interface_speed(libtrace_packet_t *packet) {
     108        if (trace_meta_check_input(packet, "trace_get_interface_speed()")<0) {
     109                return NULL;
     110        }
     111
     112        void *ptr = NULL;
     113
     114        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     115                ptr = packet->trace->format->get_meta_data(packet,
     116                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_SPEED);
     117        }
     118        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     119                ptr = packet->trace->format->get_meta_data(packet,
     120                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_SPEED);
     121        }
     122
     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;
    110130}
    111131
     
    113133 *
    114134 * @params libtrace_packet_t packet
    115  * @returns A pointer to the IP4 address field within the packet
    116  */
    117 uint32_t trace_get_interface_ip4(libtrace_packet_t *packet) {
    118         void *ptr = packet->trace->format->get_meta_data(packet,
    119                 ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
    120 
    121         if (ptr != NULL) {
    122                 uint32_t *result = (uint32_t *)(ptr+sizeof(libtrace_meta_result_t));
    123                 packet->meta.interface_ipv4 = *result;
    124 
    125                 return packet->meta.interface_ipv4;
    126         }
    127 
    128         return 0;
    129 }
    130 uint32_t trace_get_interface_ipv4(libtrace_packet_t *packet) {
     135 * @returns A pointer to the IP4 address field within the packet or NULL
     136 */
     137uint32_t *trace_get_interface_ip4(libtrace_packet_t *packet) {
     138        if (trace_meta_check_input(packet, "trace_get_interface_ip4()")<0) {
     139                return NULL;
     140        }
     141
     142        void *ptr = NULL;
     143
     144        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     145                ptr = packet->trace->format->get_meta_data(packet,
     146                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
     147        }
     148        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     149                ptr = packet->trace->format->get_meta_data(packet,
     150                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_IP4);
     151        }
     152
     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}
     161uint32_t *trace_get_interface_ipv4(libtrace_packet_t *packet) {
    131162        return trace_get_interface_ip4(packet);
    132163}
    133164
    134 char *trace_get_interface_ip6(libtrace_packet_t *packet UNUSED) {
    135         return NULL;
    136 }
    137 char *trace_get_interface_ipv6(libtrace_packet_t *packet) {
     165void *trace_get_interface_ip6(libtrace_packet_t *packet) {
     166        if (trace_meta_check_input(packet, "trace_get_interface_ip6()")<0) {
     167                return NULL;
     168        }
     169
     170        void *ptr = NULL;
     171
     172        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     173                ptr = packet->trace->format->get_meta_data(packet,
     174                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
     175        }
     176        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     177                ptr = packet->trace->format->get_meta_data(packet,
     178                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_IP4);
     179        }
     180
     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}
     188void *trace_get_interface_ipv6(libtrace_packet_t *packet) {
    138189        return trace_get_interface_ip6(packet);
    139190}
     
    142193 *
    143194 * @params libtrace_packet_t packet
    144  * @returns A char* to a NULL terminated interface description
     195 * @returns A pointer to a NULL terminated interface description string or NULL
    145196 */
    146197char *trace_get_interface_description(libtrace_packet_t *packet) {
     198        if (trace_meta_check_input(packet, "trace_get_interface_description()")<0) {
     199                return NULL;
     200        }
     201
    147202        if (packet->meta.interface_description != NULL) {
    148                 return packet->meta.interface_description;
    149         }
    150 
    151         void *ptr = packet->trace->format->get_meta_data(packet,
    152                 ERF_PROV_SECTION_INTERFACE, ERF_PROV_DESCR);
     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,
     211                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_DESCR);
     212        }
     213        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     214                ptr = packet->trace->format->get_meta_data(packet,
     215                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_DESCR);
     216        }
    153217
    154218        if (ptr != NULL) {
     
    165229}
    166230
    167 libtrace_meta_result_t *trace_get_interface_num(libtrace_packet_t *packet) {
    168         libtrace_meta_result_t *result = packet->trace->format->get_meta_data(packet,
    169                 ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_NUM);
    170         return result;
    171 }
    172 
    173 libtrace_meta_result_t *trace_get_host_os(libtrace_packet_t *packet UNUSED) {
    174         return NULL;
    175 }
    176 
    177 libtrace_meta_result_t *trace_get_tzone(libtrace_packet_t *packet UNUSED) {
    178         return NULL;
    179 }
    180 
    181 libtrace_meta_result_t *trace_get_app_name(libtrace_packet_t *packet UNUSED) {
    182         return NULL;
    183 }
     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 */
     236uint32_t *trace_get_interface_num(libtrace_packet_t *packet) {
     237        if (trace_meta_check_input(packet, "trace_get_interface_num()")<0) {
     238                return NULL;
     239        }
     240
     241        void *ptr = NULL;
     242
     243        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     244                ptr = packet->trace->format->get_meta_data(packet,
     245                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_NUM);
     246        }
     247        /* Note: pcapng doesnt provide this */
     248
     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 */
     263char *trace_get_host_os(libtrace_packet_t *packet) {
     264        if (trace_meta_check_input(packet, "trace_get_host_os()")<0) {
     265                return NULL;
     266        }
     267
     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,
     277                        ERF_PROV_SECTION_HOST, ERF_PROV_OS);
     278        }
     279        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     280                ptr = packet->trace->format->get_meta_data(packet,
     281                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_OS);
     282        }
     283
     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 */
     302uint32_t *trace_get_interface_frame_check_sequence_length(libtrace_packet_t *packet) {
     303        if (trace_meta_check_input(packet, "trace_get_interface_frame_check_sequence_length()")<0) {
     304                return NULL;
     305        }
     306
     307        void *ptr = NULL;
     308
     309        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     310                ptr = packet->trace->format->get_meta_data(packet,
     311                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_FCS_LEN);
     312        }
     313        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     314                ptr = packet->trace->format->get_meta_data(packet,
     315                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_FCSLEN);
     316        }
     317
     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
     333char *trace_get_interface_hardware_description(libtrace_packet_t *packet) {
     334        if (trace_meta_check_input(packet, "trace_get_interface_hardware_description()")<0) {
     335                return NULL;
     336        }
     337
     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
     345        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     346                ptr = packet->trace->format->get_meta_data(packet,
     347                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_HARDWARE);
     348        }
     349        /* Posibly can get ERF interface model here?? */
     350
     351        if (ptr != NULL) {
     352                libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
     353                packet->meta.interface_hardware_desc = malloc(ntohs(result->len)+1);
     354                packet->meta.interface_hardware_desc[ntohs(result->len)] = '\0';
     355                memcpy(packet->meta.interface_hardware_desc, ptr+sizeof(libtrace_meta_result_t),
     356                        ntohs(result->len));
     357
     358                return packet->meta.interface_hardware_desc;
     359        }
     360
     361        return NULL;
     362}
     363
     364char *trace_get_interface_comment(libtrace_packet_t *packet) {
     365        if (trace_meta_check_input(packet, "trace_get_interface_comment()")<0) {
     366                return NULL;
     367        }
     368
     369        if (packet->meta.interface_comment != NULL) {
     370                free(packet->meta.interface_comment);
     371                packet->meta.interface_comment = NULL;
     372        }
     373
     374        void *ptr = NULL;
     375
     376        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     377                ptr = packet->trace->format->get_meta_data(packet,
     378                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_COMMENT);
     379        }
     380        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     381                ptr = packet->trace->format->get_meta_data(packet,
     382                        PCAPNG_INTERFACE_TYPE, PCAPNG_OPTION_COMMENT);
     383        }
     384
     385        if (ptr != NULL) {
     386                libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
     387                packet->meta.interface_comment = malloc(ntohs(result->len)+1);
     388                packet->meta.interface_comment[ntohs(result->len)] = '\0';
     389                memcpy(packet->meta.interface_comment, ptr+sizeof(libtrace_meta_result_t),
     390                        ntohs(result->len));
     391
     392                return packet->meta.interface_comment;
     393        }
     394
     395        return NULL;
     396}
     397
     398char *trace_get_capture_application(libtrace_packet_t *packet) {
     399        if (trace_meta_check_input(packet, "trace_get_interface_comment()")<0) {
     400                return NULL;
     401        }
     402
     403        if (packet->meta.capture_application != NULL) {
     404                free(packet->meta.capture_application);
     405                packet->meta.capture_application = NULL;
     406        }
     407
     408        void *ptr = NULL;
     409
     410        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     411                ptr = packet->trace->format->get_meta_data(packet,
     412                        ERF_PROV_SECTION_CAPTURE, ERF_PROV_APP_NAME);
     413        }
     414        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     415                ptr = packet->trace->format->get_meta_data(packet,
     416                        PCAPNG_SECTION_TYPE, PCAPNG_META_SHB_USERAPPL);
     417        }
     418
     419        if (ptr != NULL) {
     420                libtrace_meta_result_t *result = (libtrace_meta_result_t *)ptr;
     421                packet->meta.capture_application = malloc(ntohs(result->len)+1);
     422                packet->meta.capture_application[ntohs(result->len)] = '\0';
     423                memcpy(packet->meta.capture_application, ptr+sizeof(libtrace_meta_result_t),
     424                        ntohs(result->len));
     425
     426                return packet->meta.capture_application;
     427        }
     428
     429        return NULL;
     430}
     431
     432
  • lib/libtrace.h.in

    r977e0db re7132d6  
    588588typedef struct libtrace_meta {
    589589        char *interface_name;           /**< Interface name packet was captured on */
    590         char *interface_mac;            /**< Interface MAC address packet was captured on */
     590        void *interface_mac;            /**< Interface MAC address packet was captured on */
    591591        uint64_t interface_speed;       /**< Interface speed packet was captured on */
    592592        uint32_t interface_ipv4;        /**< Interface IP4 address packet was captured on */
    593         char *interface_ipv6;           /**< Interface IP6 address packet was captured on */
     593        void *interface_ipv6;           /**< Interface IP6 address packet was captured on */
    594594        char *interface_description;    /**< Interface description */
     595        uint32_t interface_num;         /**< Interface number */
     596        char *host_os;                  /**< Host OS the packet was captured on */
     597        uint32_t interface_fcslen;      /**< Frame check sequence length for the interface */
     598        char *interface_hardware_desc;  /**< Interface hardware description string */
     599        char *interface_comment;        /**< Interface comment */
     600        char *capture_application;      /**< Name of the capturing application */
    595601} libtrace_meta_t;
    596602
     
    37153721
    37163722char *trace_get_interface_name(libtrace_packet_t *packet);
    3717 char *trace_get_interface_mac(libtrace_packet_t *packet);
    3718 uint64_t trace_get_interface_speed(libtrace_packet_t *packet);
    3719 uint32_t trace_get_interface_ip4(libtrace_packet_t *packet);
    3720 uint32_t trace_get_interface_ipv4(libtrace_packet_t *packet);
    3721 char *trace_get_interface_ip6(libtrace_packet_t *packet);
    3722 char *trace_get_interface_ipv6(libtrace_packet_t *packet);
     3723void *trace_get_interface_mac(libtrace_packet_t *packet);
     3724uint64_t *trace_get_interface_speed(libtrace_packet_t *packet);
     3725uint32_t *trace_get_interface_ip4(libtrace_packet_t *packet);
     3726uint32_t *trace_get_interface_ipv4(libtrace_packet_t *packet);
     3727void *trace_get_interface_ip6(libtrace_packet_t *packet);
     3728void *trace_get_interface_ipv6(libtrace_packet_t *packet);
    37233729char *trace_get_interface_description(libtrace_packet_t *packet);
    3724 libtrace_meta_result_t *trace_get_interface_num(libtrace_packet_t *packet);
    3725 libtrace_meta_result_t *trace_get_host_os(libtrace_packet_t *packet);
    3726 libtrace_meta_result_t *trace_get_tzone(libtrace_packet_t *packet);
    3727 libtrace_meta_result_t *trace_get_app_name(libtrace_packet_t *packet);
     3730uint32_t *trace_get_interface_num(libtrace_packet_t *packet);
     3731char *trace_get_host_os(libtrace_packet_t *packet);
     3732uint32_t *trace_get_interface_frame_check_sequence_length(libtrace_packet_t *packet);
     3733char *trace_get_interface_hardware_description(libtrace_packet_t *packet);
     3734char *trace_get_interface_comment(libtrace_packet_t *packet);
     3735char *trace_get_capture_application(libtrace_packet_t *packet);
    37283736
    37293737#endif /* LIBTRACE_H_ */
  • lib/trace.c

    r977e0db re7132d6  
    950950        if (packet->meta.interface_name != NULL)
    951951                free(packet->meta.interface_name);
    952         if (packet->meta.interface_mac != NULL)
    953                 free(packet->meta.interface_mac);
    954         if (packet->meta.interface_ipv6 != NULL)
    955                 free(packet->meta.interface_ipv6);
    956952        if (packet->meta.interface_description != NULL)
    957953                free(packet->meta.interface_description);
     954        if (packet->meta.host_os != NULL)
     955                free(packet->meta.host_os);
     956        if (packet->meta.interface_hardware_desc != NULL)
     957                free(packet->meta.interface_hardware_desc);
     958        if (packet->meta.interface_comment != NULL)
     959                free(packet->meta.interface_comment);
     960        if (packet->meta.capture_application != NULL)
     961                free(packet->meta.capture_application);
    958962
    959963        free(packet);
Note: See TracChangeset for help on using the changeset viewer.