source: lib/format_pktmeta.c @ e7132d6

develop
Last change on this file since e7132d6 was e7132d6, checked in by Jacob Van Walraven <jcv9@…>, 22 months ago

improvements to meta-api

  • Property mode set to 100644
File size: 13.2 KB
Line 
1#include "libtrace_int.h"
2#include "libtrace.h"
3#include "format_erf.h"
4#include "format_pcapng.h"
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <string.h>
9
10
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
25/* API functions to retrieve interface related packet data */
26
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 */
32char *trace_get_interface_name(libtrace_packet_t *packet) {
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 */
40        if (packet->meta.interface_name != NULL) {
41                free(packet->meta.interface_name);
42                packet->meta.interface_name = NULL;
43        }
44
45        /* get the result */
46        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
47                ptr = packet->trace->format->get_meta_data(packet,
48                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_NAME);
49        }
50        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
51                ptr = packet->trace->format->get_meta_data(packet,
52                        PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_NAME);
53        }
54
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 */
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);
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 */
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;
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 */
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) {
162        return trace_get_interface_ip4(packet);
163}
164
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) {
189        return trace_get_interface_ip6(packet);
190}
191
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 */
197char *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
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,
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        }
217
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 */
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 TracBrowser for help on using the repository browser.