source: lib/linktypes.c @ 742a332

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since 742a332 was 742a332, checked in by Perry Lorier <perry@…>, 15 years ago

Define possibly missing ARPHRD

  • Property mode set to 100644
File size: 5.9 KB
Line 
1#include "libtrace.h"
2#include "config.h"
3
4#include "rt_protocol.h"
5#include <assert.h>
6#include "libtrace_int.h"
7#include <stdlib.h>
8#include <string.h>
9
10#ifndef WIN32
11#include <net/if_arp.h>
12#endif
13
14#ifndef ARPHRD_ETHER
15#define ARPHRD_ETHER    1               /* Ethernet 10/100Mbps.  */
16#endif
17
18#ifndef ARPHRD_PPP
19#define ARPHRD_PPP      512
20#endif
21
22#ifndef ARPHRD_IEEE80211
23#define ARPHRD_IEEE80211        801
24#endif
25
26
27/* This file maps libtrace types to/from pcap DLT and erf types
28 *
29 * When adding a new linktype to libtrace, add the mapping(s) here,
30 * and add the understanding of the type to get_ip(), and perhaps
31 * get_{source,destination}_mac (if your linklayer has mac's)
32 */
33
34libtrace_linktype_t pcap_dlt_to_libtrace(libtrace_dlt_t dlt)
35{
36        switch(dlt) {
37                case TRACE_DLT_NULL: return TRACE_TYPE_NONE;
38                case TRACE_DLT_EN10MB: return TRACE_TYPE_ETH;
39                case TRACE_DLT_ATM_RFC1483: return TRACE_TYPE_ATM;
40                case TRACE_DLT_IEEE802_11: return TRACE_TYPE_80211;
41                case TRACE_DLT_LINUX_SLL: return TRACE_TYPE_LINUX_SLL;
42                case TRACE_DLT_PFLOG: return TRACE_TYPE_PFLOG;
43        case TRACE_DLT_IEEE802_11_RADIO: return TRACE_TYPE_80211_RADIO;
44        }
45        return ~0;
46}
47
48libtrace_dlt_t libtrace_to_pcap_dlt(libtrace_linktype_t type)
49{
50        switch(type) {
51                case TRACE_TYPE_NONE: return TRACE_DLT_NULL;
52                case TRACE_TYPE_ETH: return TRACE_DLT_EN10MB;
53                case TRACE_TYPE_ATM: return TRACE_DLT_ATM_RFC1483;
54                case TRACE_TYPE_80211: return TRACE_DLT_IEEE802_11;
55                case TRACE_TYPE_LINUX_SLL: return TRACE_DLT_LINUX_SLL;
56                case TRACE_TYPE_PFLOG: return TRACE_DLT_PFLOG;
57        case TRACE_TYPE_80211_RADIO: return TRACE_DLT_IEEE802_11_RADIO;
58        }
59        return ~0;
60}
61
62enum rt_field_t pcap_dlt_to_rt(libtrace_dlt_t dlt) 
63{
64        /* For pcap the rt type is just the dlt + a fixed value */
65        return dlt + RT_DATA_PCAP;
66}
67
68libtrace_dlt_t rt_to_pcap_dlt(enum rt_field_t rt_type)
69{
70        assert(rt_type >= RT_DATA_PCAP);
71        return rt_type - RT_DATA_PCAP;
72}
73
74libtrace_linktype_t erf_type_to_libtrace(char erf)
75{
76        switch (erf) {
77                case TYPE_HDLC_POS:     return TRACE_TYPE_HDLC_POS;
78                case TYPE_ETH:          return TRACE_TYPE_ETH;
79                case TYPE_ATM:          return TRACE_TYPE_ATM;
80                case TYPE_AAL5:         return TRACE_TYPE_AAL5;
81        }
82        return ~0;
83}
84
85char libtrace_to_erf_type(libtrace_linktype_t linktype)
86{
87        switch(linktype) {
88                case TRACE_TYPE_HDLC_POS: return TYPE_HDLC_POS;
89                case TRACE_TYPE_ETH:    return TYPE_ETH;
90                case TRACE_TYPE_ATM:    return TYPE_ATM;
91                case TRACE_TYPE_AAL5:   return TYPE_AAL5;
92        }
93        return -1;
94}
95
96libtrace_linktype_t arphrd_type_to_libtrace(unsigned int arphrd) {
97        switch(arphrd) {
98                case ARPHRD_ETHER: return TRACE_TYPE_ETH;       
99                case ARPHRD_IEEE80211: return TRACE_TYPE_80211;
100                case ARPHRD_80211_RADIOTAP: return TRACE_TYPE_80211_RADIO;
101        }
102        return ~0;
103}
104
105unsigned int libtrace_to_arphrd_type(libtrace_linktype_t linktype) {
106        switch(linktype) {
107                case TRACE_TYPE_ETH: return ARPHRD_ETHER;
108                case TRACE_TYPE_80211: return ARPHRD_IEEE80211;
109                case TRACE_TYPE_80211_RADIO: return ARPHRD_80211_RADIOTAP;
110        }
111        return -1;
112}
113
114/** Tinker with a packet
115 * packets that don't support direction tagging are annoying, especially
116 * when we have direction tagging information!  So this converts the packet
117 * to TRACE_TYPE_LINUX_SLL which does support direction tagging.  This is a
118 * pcap style packet for the reason that it means it works with bpf filters.
119 *
120 * @note this will copy the packet, so use sparingly if possible.
121 */
122void promote_packet(libtrace_packet_t *packet)
123{
124        if (packet->trace->format->type == TRACE_FORMAT_PCAP) {
125                char *tmpbuffer;
126                libtrace_sll_header_t *hdr;
127
128                switch(pcap_dlt_to_libtrace(rt_to_pcap_dlt(packet->type))) {
129                        case TRACE_TYPE_LINUX_SLL:
130                                return; /* Unnecessary */
131
132                        case TRACE_TYPE_NONE:
133                        case TRACE_TYPE_ETH:
134                                /* This should be easy, just prepend the header */
135                                tmpbuffer= (char*)malloc(
136                                                sizeof(libtrace_sll_header_t)
137                                                +trace_get_capture_length(packet)
138                                                +trace_get_framing_length(packet)
139                                                );
140
141                                hdr=(libtrace_sll_header_t*)((char*)tmpbuffer
142                                        +trace_get_framing_length(packet));
143
144                                hdr->pkttype=TRACE_SLL_OUTGOING;
145                                if (pcap_dlt_to_libtrace(rt_to_pcap_dlt(packet->type))==TRACE_TYPE_ETH)
146                                        hdr->hatype = htons(ARPHRD_ETHER);
147                                else
148                                        hdr->hatype = htons(ARPHRD_PPP);
149                                trace_get_payload_from_link(
150                                        trace_get_link(packet),
151                                        trace_get_link_type(packet),
152                                        &hdr->protocol,
153                                        NULL);
154                                /* Linux SLL appears to have the protocol
155                                 * field in /host/ byte order.
156                                 */
157                                hdr->protocol=ntohs(hdr->protocol);
158                                break;
159                        default:
160                                /* failed */
161                                return;
162                }
163                memcpy(tmpbuffer,packet->header,
164                                trace_get_framing_length(packet));
165                memcpy(tmpbuffer
166                                +sizeof(libtrace_sll_header_t)
167                                +trace_get_framing_length(packet),
168                                packet->payload,
169                                trace_get_capture_length(packet));
170                if (packet->buf_control == TRACE_CTRL_EXTERNAL) {
171                        packet->buf_control=TRACE_CTRL_PACKET;
172                }
173                else {
174                        free(packet->buffer);
175                }
176                packet->buffer=tmpbuffer;
177                packet->header=tmpbuffer;
178                packet->payload=tmpbuffer+trace_get_framing_length(packet);
179                packet->type=pcap_dlt_to_rt(TRACE_DLT_LINUX_SLL);
180                ((struct pcap_pkthdr*) packet->header)->caplen+=
181                        sizeof(libtrace_sll_header_t);
182                ((struct pcap_pkthdr*) packet->header)->len+=
183                        sizeof(libtrace_sll_header_t);
184                return;
185        }
186}
187
188/* Try and simplify the packet one step, kinda the opposite to promote_packet
189 *
190 * returns true if demotion was possible, false if not.
191 */
192bool demote_packet(libtrace_packet_t *packet)
193{
194        switch(trace_get_link_type(packet)) {
195                case TRACE_TYPE_LINUX_SLL:
196                        switch(ntohs(((libtrace_sll_header_t*)packet->payload)
197                                        ->hatype)) {
198                                case ARPHRD_PPP:
199                                        packet->type=pcap_dlt_to_rt(DLT_NULL);
200                                        break;
201                                case ARPHRD_ETHER:
202                                        packet->type=pcap_dlt_to_rt(DLT_EN10MB);
203                                        break;
204                                default:
205                                        /* Dunno how to demote this packet */
206                                        return false;
207                        }
208                        /* Skip the Linux SLL header */
209                        packet->payload=(void*)((char*)packet->payload
210                                        +sizeof(libtrace_sll_header_t));
211                        trace_set_capture_length(packet,
212                                trace_get_capture_length(packet)
213                                        -sizeof(libtrace_sll_header_t));
214                        break;
215                default:
216                        return false;
217        }
218        return true;
219}
Note: See TracBrowser for help on using the repository browser.