source: lib/protocols_l3.c @ 3a87f4f

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since 3a87f4f was 3a87f4f, checked in by Shane Alcock <salcock@…>, 13 years ago
  • Ensure that remaining is not null before changing the value
  • Property mode set to 100644
File size: 7.5 KB
Line 
1/* Protocol decodes for Layer 3 protocols */
2#include "libtrace.h"
3#include "protocols.h"
4#include <assert.h>
5
6libtrace_ip_t *trace_get_ip(libtrace_packet_t *packet) 
7{
8        uint16_t ethertype;
9        void *ret;
10
11        uint32_t remaining = trace_get_capture_length(packet);
12
13        ret = trace_get_layer3(packet,&ethertype,&remaining);
14
15        if (!ret || ethertype!=0x0800)
16                return NULL;
17
18        /* Make sure we have at least a base IPv4 header */
19        if (remaining < sizeof(libtrace_ip_t)) 
20                return NULL;
21       
22        /* Not an IPv4 packet */
23        if (((libtrace_ip_t*)ret)->ip_v != 4)
24                return NULL;
25
26        return (libtrace_ip_t*)ret;
27}
28
29libtrace_ip6_t *trace_get_ip6(libtrace_packet_t *packet) 
30{
31        uint16_t ethertype;
32        void *ret;
33
34        uint32_t remaining = trace_get_capture_length(packet);
35
36        ret = trace_get_layer3(packet,&ethertype,&remaining);
37
38        if (!ret || ethertype!=0x86DD)
39                return NULL;
40
41        return (libtrace_ip6_t*)ret;
42}
43
44#define SW_IP_OFFMASK 0x1fff
45
46DLLEXPORT void *trace_get_payload_from_ip(libtrace_ip_t *ipptr, uint8_t *prot,
47                uint32_t *remaining) 
48{
49        void *trans_ptr = 0;
50
51        if ((ntohs(ipptr->ip_off) & SW_IP_OFFMASK) != 0) {
52                if (remaining)
53                        *remaining = 0;         
54                return NULL;
55        }
56
57        if (remaining) {
58                if (*remaining<=(ipptr->ip_hl*4U)) {
59                        *remaining = 0;
60                        return NULL;
61                }
62                *remaining-=(ipptr->ip_hl * 4);
63        }
64
65        trans_ptr = (void *)((char *)ipptr + (ipptr->ip_hl * 4));
66
67        if (prot) *prot = ipptr->ip_p;
68
69        return trans_ptr;
70}
71
72void *trace_get_payload_from_ip6(libtrace_ip6_t *ipptr, uint8_t *prot,
73                uint32_t *remaining) 
74{
75        void *payload = (char*)ipptr+sizeof(libtrace_ip6_t);
76        uint8_t nxt = ipptr->nxt;
77
78        if (remaining) {
79                if (*remaining<sizeof(libtrace_ip6_t)) {
80                        *remaining = 0;
81                        return NULL;
82                }
83                *remaining-=sizeof(libtrace_ip6_t);
84        }
85
86        while(1) {
87                switch (nxt) {
88                        case 0: /* hop by hop options */
89                        case 43: /* routing */
90                        case 44: /* fragment */
91                        case 50: /* ESP */
92                        case 51: /* AH */
93                        case 60: /* Destination options */
94                                {
95                                        uint16_t len=((libtrace_ip6_ext_t*)payload)->len
96                                        +sizeof(libtrace_ip6_ext_t);
97
98                                        if (remaining) {
99                                                if (*remaining < len) {
100                                                        /* Snap too short */
101                                                        *remaining = 0;
102                                                        return NULL;
103                                                }
104                                                *remaining-=len;
105                                        }
106
107                                        payload=(char*)payload+len;
108                                        nxt=((libtrace_ip6_ext_t*)payload)->nxt;
109                                        continue;
110                                }
111                        default:
112                                if (prot) *prot=nxt;
113                                return payload;
114                }
115        }
116}
117
118DLLEXPORT void *trace_get_layer3(const libtrace_packet_t *packet,
119                uint16_t *ethertype,
120                uint32_t *remaining)
121{
122        void *iphdr;
123        uint16_t dummy_ethertype;
124        void *link;
125        uint32_t dummy_remaining;
126        libtrace_linktype_t linktype;
127
128        if (!ethertype) ethertype=&dummy_ethertype;
129
130        if (!remaining) remaining=&dummy_remaining;
131
132        /* use l3 cache */
133        if (packet->l3_header)
134        {
135                link = trace_get_packet_buffer(packet,&linktype,remaining);
136
137                if (!link)
138                        return NULL;
139
140                *ethertype = packet->l3_ethertype;
141                *remaining -= (packet->l3_header - link);
142
143                return packet->l3_header;
144        }
145
146        link = trace_get_layer2(packet,&linktype,remaining);
147        iphdr = trace_get_payload_from_layer2(
148                        link,
149                        linktype,
150                        ethertype,
151                        remaining);
152
153        for(;;) {
154                if (!iphdr || *remaining == 0)
155                        return NULL;
156                switch(*ethertype) {
157                case 0x8100: /* VLAN */
158                        iphdr=trace_get_vlan_payload_from_ethernet_payload(
159                                          iphdr,ethertype,remaining);
160                        continue;
161                case 0x8847: /* MPLS */
162                        iphdr=trace_get_mpls_payload_from_ethernet_payload(
163                                          iphdr,ethertype,remaining);
164
165                        if (iphdr && ethertype == 0x0) {
166                                iphdr=trace_get_payload_from_ethernet(
167                                                iphdr,ethertype,remaining);
168                        }
169                        continue;
170                default:
171                        break;
172                }
173
174                break;
175        }
176
177        if (!iphdr || *remaining == 0)
178                return NULL;
179
180        /* Store values in the cache for later */
181        /* Cast away constness, nasty, but this is just a cache */
182        ((libtrace_packet_t*)packet)->l3_ethertype = *ethertype;
183        ((libtrace_packet_t*)packet)->l3_header = iphdr;
184
185        return iphdr;
186}
187
188/* parse an ip or tcp option
189 * @param[in,out] ptr   the pointer to the current option
190 * @param[in,out] len   the length of the remaining buffer
191 * @param[out] type     the type of the option
192 * @param[out] optlen   the length of the option
193 * @param[out] data     the data of the option
194 *
195 * @returns bool true if there is another option (and the fields are filled in)
196 *               or false if this was the last option.
197 *
198 * This updates ptr to point to the next option after this one, and updates
199 * len to be the number of bytes remaining in the options area.  Type is updated
200 * to be the code of this option, and data points to the data of this option,
201 * with optlen saying how many bytes there are.
202 *
203 * @note Beware of fragmented packets.
204 * @author Perry Lorier
205 */
206DLLEXPORT int trace_get_next_option(unsigned char **ptr,int *len,
207                        unsigned char *type,
208                        unsigned char *optlen,
209                        unsigned char **data)
210{
211        if (*len<=0)
212                return 0;
213        *type=**ptr;
214        switch(*type) {
215                case 0: /* End of options */
216                        return 0;
217                case 1: /* Pad */
218                        (*ptr)++;
219                        (*len)--;
220                        return 1;
221                default:
222                        *optlen = *(*ptr+1);
223                        if (*optlen<2)
224                                return 0; /* I have no idea wtf is going on
225                                           * with these packets
226                                           */
227                        (*len)-=*optlen;
228                        (*data)=(*ptr+2);
229                        (*ptr)+=*optlen;
230                        if (*len<0)
231                                return 0;
232                        return 1;
233        }
234        assert(0);
235}
236
237DLLEXPORT struct sockaddr *trace_get_source_address(
238                const libtrace_packet_t *packet, struct sockaddr *addr)
239{
240        uint16_t ethertype;
241        uint32_t remaining;
242        void *l3;
243        struct ports_t *ports;
244        static struct sockaddr_storage dummy;
245
246        if (!addr)
247                addr=(struct sockaddr*)&dummy;
248
249        l3 = trace_get_layer3(packet,&ethertype,&remaining);
250
251        if (!l3)
252                return NULL;
253
254        switch (ethertype) {
255                case 0x0800: /* IPv4 */
256                {
257                        struct sockaddr_in *addr4=(struct sockaddr_in*)addr;
258                        libtrace_ip_t *ip = (libtrace_ip_t*)l3;
259                        ports = (struct ports_t*)
260                                trace_get_payload_from_ip(ip,NULL,&remaining);
261                        addr4->sin_family=AF_INET;
262                        if (ports && remaining>=sizeof(*ports))
263                                addr4->sin_port=ports->src;
264                        else
265                                addr4->sin_port=0;
266                        addr4->sin_addr=ip->ip_src;
267                        return addr;
268                }
269                case 0x86DD: /* IPv6 */
270                {
271                        struct sockaddr_in6 *addr6=(struct sockaddr_in6*)addr;
272                        libtrace_ip6_t *ip6 = (libtrace_ip6_t*)l3;
273                        ports = (struct ports_t*)
274                                trace_get_payload_from_ip6(ip6,NULL,&remaining);
275                        addr6->sin6_family=AF_INET6;
276                        if (ports && remaining>=sizeof(*ports))
277                                addr6->sin6_port=ports->src;
278                        else
279                                addr6->sin6_port=0;
280                        addr6->sin6_flowinfo=0;
281                        addr6->sin6_addr=ip6->ip_src;
282                        return addr;
283                }
284                default:
285                        return NULL;
286        }
287}
288
289DLLEXPORT struct sockaddr *trace_get_destination_address(
290                const libtrace_packet_t *packet, struct sockaddr *addr)
291{
292        uint16_t ethertype;
293        uint32_t remaining;
294        void *l3;
295        struct ports_t *ports;
296        static struct sockaddr_storage dummy;
297
298        if (!addr)
299                addr=(struct sockaddr*)&dummy;
300
301        l3 = trace_get_layer3(packet,&ethertype,&remaining);
302
303        if (!l3)
304                return NULL;
305
306        switch (ethertype) {
307                case 0x0800: /* IPv4 */
308                {
309                        struct sockaddr_in *addr4=(struct sockaddr_in*)addr;
310                        libtrace_ip_t *ip = (libtrace_ip_t*)l3;
311                        ports = (struct ports_t*)
312                                trace_get_payload_from_ip(ip,NULL,&remaining);
313                        addr4->sin_family=AF_INET;
314                        if (ports && remaining>=sizeof(*ports))
315                                addr4->sin_port=ports->dst;
316                        else
317                                addr4->sin_port=0;
318                        addr4->sin_addr=ip->ip_dst;
319                        return addr;
320                }
321                case 0x86DD: /* IPv6 */
322                {
323                        struct sockaddr_in6 *addr6=(struct sockaddr_in6*)addr;
324                        libtrace_ip6_t *ip6 = (libtrace_ip6_t*)l3;
325                        ports = (struct ports_t*)
326                                trace_get_payload_from_ip6(ip6,NULL,&remaining);
327                        addr6->sin6_family=AF_INET6;
328                        if (ports && remaining>=sizeof(*ports))
329                                addr6->sin6_port=ports->dst;
330                        else
331                                addr6->sin6_port=0;
332                        addr6->sin6_flowinfo=0;
333                        addr6->sin6_addr=ip6->ip_dst;
334                        return addr;
335                }
336                default:
337                        return NULL;
338        }
339}
340
341
Note: See TracBrowser for help on using the repository browser.