source: lib/format_pktmeta.c @ 629b19b

develop
Last change on this file since 629b19b was 629b19b, checked in by Jacob Van Walraven <jcv9@…>, 2 years ago

Use ERF model for trace_get_interface_hardware_description()

  • Property mode set to 100644
File size: 13.3 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        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
350                ptr = packet->trace->format->get_meta_data(packet,
351                        ERF_PROV_SECTION_MODULE, ERF_PROV_MODEL);
352        }
353
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
367char *trace_get_interface_comment(libtrace_packet_t *packet) {
368        if (trace_meta_check_input(packet, "trace_get_interface_comment()")<0) {
369                return NULL;
370        }
371
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,
381                        ERF_PROV_SECTION_INTERFACE, ERF_PROV_COMMENT);
382        }
383        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
384                ptr = packet->trace->format->get_meta_data(packet,
385                        PCAPNG_INTERFACE_TYPE, PCAPNG_OPTION_COMMENT);
386        }
387
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
401char *trace_get_capture_application(libtrace_packet_t *packet) {
402        if (trace_meta_check_input(packet, "trace_get_interface_comment()")<0) {
403                return NULL;
404        }
405
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,
415                        ERF_PROV_SECTION_CAPTURE, ERF_PROV_APP_NAME);
416        }
417        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
418                ptr = packet->trace->format->get_meta_data(packet,
419                        PCAPNG_SECTION_TYPE, PCAPNG_META_SHB_USERAPPL);
420        }
421
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
432        return NULL;
433}
434
435
Note: See TracBrowser for help on using the repository browser.