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

File:
1 edited

Legend:

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