Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/samples/bpf/parse_varlen.c
25924 views
1
/* Copyright (c) 2016 Facebook

2
 *

3
 * This program is free software; you can redistribute it and/or

4
 * modify it under the terms of version 2 of the GNU General Public

5
 * License as published by the Free Software Foundation.

6
 */

7
#define KBUILD_MODNAME "foo"

8
#include <linux/if_ether.h>

9
#include <linux/if_vlan.h>

10
#include <linux/ip.h>

11
#include <linux/ipv6.h>

12
#include <linux/in.h>

13
#include <linux/tcp.h>

14
#include <linux/udp.h>

15
#include <uapi/linux/bpf.h>

16
#include <net/ip.h>

17
#include <bpf/bpf_helpers.h>

18


19
#define DEFAULT_PKTGEN_UDP_PORT 9

20
#define DEBUG 0

21


22
static int tcp(void *data, uint64_t tp_off, void *data_end)

23
{

24
	struct tcphdr *tcp = data + tp_off;

25


26
	if (tcp + 1 > data_end)

27
		return 0;

28
	if (tcp->dest == htons(80) || tcp->source == htons(80))

29
		return TC_ACT_SHOT;

30
	return 0;

31
}

32


33
static int udp(void *data, uint64_t tp_off, void *data_end)

34
{

35
	struct udphdr *udp = data + tp_off;

36


37
	if (udp + 1 > data_end)

38
		return 0;

39
	if (udp->dest == htons(DEFAULT_PKTGEN_UDP_PORT) ||

40
	    udp->source == htons(DEFAULT_PKTGEN_UDP_PORT)) {

41
		if (DEBUG) {

42
			char fmt[] = "udp port 9 indeed\n";

43


44
			bpf_trace_printk(fmt, sizeof(fmt));

45
		}

46
		return TC_ACT_SHOT;

47
	}

48
	return 0;

49
}

50


51
static int parse_ipv4(void *data, uint64_t nh_off, void *data_end)

52
{

53
	struct iphdr *iph;

54
	uint64_t ihl_len;

55


56
	iph = data + nh_off;

57
	if (iph + 1 > data_end)

58
		return 0;

59


60
	if (ip_is_fragment(iph))

61
		return 0;

62
	ihl_len = iph->ihl * 4;

63


64
	if (iph->protocol == IPPROTO_IPIP) {

65
		iph = data + nh_off + ihl_len;

66
		if (iph + 1 > data_end)

67
			return 0;

68
		ihl_len += iph->ihl * 4;

69
	}

70


71
	if (iph->protocol == IPPROTO_TCP)

72
		return tcp(data, nh_off + ihl_len, data_end);

73
	else if (iph->protocol == IPPROTO_UDP)

74
		return udp(data, nh_off + ihl_len, data_end);

75
	return 0;

76
}

77


78
static int parse_ipv6(void *data, uint64_t nh_off, void *data_end)

79
{

80
	struct ipv6hdr *ip6h;

81
	struct iphdr *iph;

82
	uint64_t ihl_len = sizeof(struct ipv6hdr);

83
	uint64_t nexthdr;

84


85
	ip6h = data + nh_off;

86
	if (ip6h + 1 > data_end)

87
		return 0;

88


89
	nexthdr = ip6h->nexthdr;

90


91
	if (nexthdr == IPPROTO_IPIP) {

92
		iph = data + nh_off + ihl_len;

93
		if (iph + 1 > data_end)

94
			return 0;

95
		ihl_len += iph->ihl * 4;

96
		nexthdr = iph->protocol;

97
	} else if (nexthdr == IPPROTO_IPV6) {

98
		ip6h = data + nh_off + ihl_len;

99
		if (ip6h + 1 > data_end)

100
			return 0;

101
		ihl_len += sizeof(struct ipv6hdr);

102
		nexthdr = ip6h->nexthdr;

103
	}

104


105
	if (nexthdr == IPPROTO_TCP)

106
		return tcp(data, nh_off + ihl_len, data_end);

107
	else if (nexthdr == IPPROTO_UDP)

108
		return udp(data, nh_off + ihl_len, data_end);

109
	return 0;

110
}

111


112
SEC("varlen")

113
int handle_ingress(struct __sk_buff *skb)

114
{

115
	void *data = (void *)(long)skb->data;

116
	struct ethhdr *eth = data;

117
	void *data_end = (void *)(long)skb->data_end;

118
	uint64_t h_proto, nh_off;

119


120
	nh_off = sizeof(*eth);

121
	if (data + nh_off > data_end)

122
		return 0;

123


124
	h_proto = eth->h_proto;

125


126
	if (h_proto == ETH_P_8021Q || h_proto == ETH_P_8021AD) {

127
		struct vlan_hdr *vhdr;

128


129
		vhdr = data + nh_off;

130
		nh_off += sizeof(struct vlan_hdr);

131
		if (data + nh_off > data_end)

132
			return 0;

133
		h_proto = vhdr->h_vlan_encapsulated_proto;

134
	}

135
	if (h_proto == ETH_P_8021Q || h_proto == ETH_P_8021AD) {

136
		struct vlan_hdr *vhdr;

137


138
		vhdr = data + nh_off;

139
		nh_off += sizeof(struct vlan_hdr);

140
		if (data + nh_off > data_end)

141
			return 0;

142
		h_proto = vhdr->h_vlan_encapsulated_proto;

143
	}

144
	if (h_proto == htons(ETH_P_IP))

145
		return parse_ipv4(data, nh_off, data_end);

146
	else if (h_proto == htons(ETH_P_IPV6))

147
		return parse_ipv6(data, nh_off, data_end);

148
	return 0;

149
}

150
char _license[] SEC("license") = "GPL";

151


152