]>
Commit | Line | Data |
---|---|---|
b9e8b45a | 1 | /* |
6335d074 | 2 | * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc. |
b9e8b45a BP |
3 | * |
4 | * Licensed under the Apache License, Version 2.0 (the "License"); | |
5 | * you may not use this file except in compliance with the License. | |
6 | * You may obtain a copy of the License at: | |
7 | * | |
8 | * http://www.apache.org/licenses/LICENSE-2.0 | |
9 | * | |
10 | * Unless required by applicable law or agreed to in writing, software | |
11 | * distributed under the License is distributed on an "AS IS" BASIS, | |
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
13 | * See the License for the specific language governing permissions and | |
14 | * limitations under the License. | |
15 | */ | |
16 | ||
17 | #include <config.h> | |
18 | #include "packets.h" | |
b2befd5b BP |
19 | #include <sys/types.h> |
20 | #include <netinet/in.h> | |
d31f1109 | 21 | #include <arpa/inet.h> |
6ca00f6f | 22 | #include <sys/socket.h> |
bc7a5acd | 23 | #include <netinet/ip6.h> |
00894212 | 24 | #include <netinet/icmp6.h> |
76343538 | 25 | #include <stdlib.h> |
e463f310 | 26 | #include <netdb.h> |
d31f1109 | 27 | #include "byte-order.h" |
c97664b3 | 28 | #include "csum.h" |
c6bcb685 | 29 | #include "crc32c.h" |
12113c39 | 30 | #include "flow.h" |
ee89ea7b | 31 | #include "openvswitch/hmap.h" |
3e8a2ad1 | 32 | #include "openvswitch/dynamic-string.h" |
8c45d00f | 33 | #include "ovs-thread.h" |
b5e7e61a | 34 | #include "odp-util.h" |
cf62fa4c | 35 | #include "dp-packet.h" |
7c457c33 | 36 | #include "unaligned.h" |
b9e8b45a | 37 | |
d31f1109 | 38 | const struct in6_addr in6addr_exact = IN6ADDR_EXACT_INIT; |
06994f87 | 39 | const struct in6_addr in6addr_all_hosts = IN6ADDR_ALL_HOSTS_INIT; |
b24ab67c | 40 | const struct in6_addr in6addr_all_routers = IN6ADDR_ALL_ROUTERS_INIT; |
d31f1109 | 41 | |
ffe4c74f JB |
42 | struct in6_addr |
43 | flow_tnl_dst(const struct flow_tnl *tnl) | |
44 | { | |
12d0ee08 | 45 | return tnl->ip_dst ? in6_addr_mapped_ipv4(tnl->ip_dst) : tnl->ipv6_dst; |
ffe4c74f JB |
46 | } |
47 | ||
48 | struct in6_addr | |
49 | flow_tnl_src(const struct flow_tnl *tnl) | |
50 | { | |
12d0ee08 | 51 | return tnl->ip_src ? in6_addr_mapped_ipv4(tnl->ip_src) : tnl->ipv6_src; |
ffe4c74f JB |
52 | } |
53 | ||
62705b81 BP |
54 | /* Returns true if 's' consists entirely of hex digits, false otherwise. */ |
55 | static bool | |
56 | is_all_hex(const char *s) | |
57 | { | |
58 | return s[strspn(s, "0123456789abcdefABCDEF")] == '\0'; | |
59 | } | |
60 | ||
093ca5b3 BP |
61 | /* Parses 's' as a 16-digit hexadecimal number representing a datapath ID. On |
62 | * success stores the dpid into '*dpidp' and returns true, on failure stores 0 | |
63 | * into '*dpidp' and returns false. | |
64 | * | |
65 | * Rejects an all-zeros dpid as invalid. */ | |
76343538 BP |
66 | bool |
67 | dpid_from_string(const char *s, uint64_t *dpidp) | |
68 | { | |
62705b81 BP |
69 | size_t len = strlen(s); |
70 | *dpidp = ((len == 16 && is_all_hex(s)) | |
71 | || (len <= 18 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') | |
72 | && is_all_hex(s + 2)) | |
093ca5b3 | 73 | ? strtoull(s, NULL, 16) |
76343538 BP |
74 | : 0); |
75 | return *dpidp != 0; | |
76 | } | |
77 | ||
7d48a4cc BP |
78 | /* Returns true if 'ea' is a reserved address, that a bridge must never |
79 | * forward, false otherwise. | |
05be4e2c EJ |
80 | * |
81 | * If you change this function's behavior, please update corresponding | |
82 | * documentation in vswitch.xml at the same time. */ | |
83 | bool | |
74ff3298 | 84 | eth_addr_is_reserved(const struct eth_addr ea) |
05be4e2c | 85 | { |
7d48a4cc BP |
86 | struct eth_addr_node { |
87 | struct hmap_node hmap_node; | |
8c45d00f | 88 | const uint64_t ea64; |
05be4e2c EJ |
89 | }; |
90 | ||
7d48a4cc BP |
91 | static struct eth_addr_node nodes[] = { |
92 | /* STP, IEEE pause frames, and other reserved protocols. */ | |
f0ac9da9 BP |
93 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000000ULL }, |
94 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000001ULL }, | |
95 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000002ULL }, | |
96 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000003ULL }, | |
97 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000004ULL }, | |
98 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000005ULL }, | |
99 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000006ULL }, | |
100 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000007ULL }, | |
101 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000008ULL }, | |
102 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000009ULL }, | |
103 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000aULL }, | |
104 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000bULL }, | |
105 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000cULL }, | |
106 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000dULL }, | |
107 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000eULL }, | |
108 | { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000fULL }, | |
7d48a4cc BP |
109 | |
110 | /* Extreme protocols. */ | |
111 | { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000000ULL }, /* EDP. */ | |
112 | { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000004ULL }, /* EAPS. */ | |
113 | { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000006ULL }, /* EAPS. */ | |
114 | ||
115 | /* Cisco protocols. */ | |
116 | { HMAP_NODE_NULL_INITIALIZER, 0x01000c000000ULL }, /* ISL. */ | |
117 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccccULL }, /* PAgP, UDLD, CDP, | |
118 | * DTP, VTP. */ | |
119 | { HMAP_NODE_NULL_INITIALIZER, 0x01000ccccccdULL }, /* PVST+. */ | |
120 | { HMAP_NODE_NULL_INITIALIZER, 0x01000ccdcdcdULL }, /* STP Uplink Fast, | |
121 | * FlexLink. */ | |
122 | ||
123 | /* Cisco CFM. */ | |
124 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc0ULL }, | |
125 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc1ULL }, | |
126 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc2ULL }, | |
127 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc3ULL }, | |
128 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc4ULL }, | |
129 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc5ULL }, | |
130 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc6ULL }, | |
131 | { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc7ULL }, | |
132 | }; | |
05be4e2c | 133 | |
8c45d00f | 134 | static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER; |
7d48a4cc | 135 | struct eth_addr_node *node; |
8c45d00f | 136 | static struct hmap addrs; |
7d48a4cc | 137 | uint64_t ea64; |
05be4e2c | 138 | |
8c45d00f BP |
139 | if (ovsthread_once_start(&once)) { |
140 | hmap_init(&addrs); | |
7d48a4cc | 141 | for (node = nodes; node < &nodes[ARRAY_SIZE(nodes)]; node++) { |
965607c8 | 142 | hmap_insert(&addrs, &node->hmap_node, hash_uint64(node->ea64)); |
7d48a4cc | 143 | } |
8c45d00f | 144 | ovsthread_once_done(&once); |
7d48a4cc | 145 | } |
05be4e2c | 146 | |
7d48a4cc | 147 | ea64 = eth_addr_to_uint64(ea); |
965607c8 | 148 | HMAP_FOR_EACH_IN_BUCKET (node, hmap_node, hash_uint64(ea64), &addrs) { |
7d48a4cc | 149 | if (node->ea64 == ea64) { |
05be4e2c EJ |
150 | return true; |
151 | } | |
152 | } | |
153 | return false; | |
154 | } | |
155 | ||
ed4c95c0 BP |
156 | /* Attempts to parse 's' as an Ethernet address. If successful, stores the |
157 | * address in 'ea' and returns true, otherwise zeros 'ea' and returns | |
10c3fcdf | 158 | * false. This function checks trailing characters. */ |
76343538 | 159 | bool |
74ff3298 | 160 | eth_addr_from_string(const char *s, struct eth_addr *ea) |
76343538 | 161 | { |
10c3fcdf | 162 | int n = 0; |
163 | if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(*ea), &n) | |
164 | && !s[n]) { | |
76343538 BP |
165 | return true; |
166 | } else { | |
74ff3298 | 167 | *ea = eth_addr_zero; |
76343538 BP |
168 | return false; |
169 | } | |
170 | } | |
171 | ||
38f7147c | 172 | /* Fills 'b' with a Reverse ARP packet with Ethernet source address 'eth_src'. |
b9e8b45a | 173 | * This function is used by Open vSwitch to compose packets in cases where |
38f7147c EJ |
174 | * context is important but content doesn't (or shouldn't) matter. |
175 | * | |
176 | * The returned packet has enough headroom to insert an 802.1Q VLAN header if | |
177 | * desired. */ | |
b9e8b45a | 178 | void |
74ff3298 | 179 | compose_rarp(struct dp_packet *b, const struct eth_addr eth_src) |
b9e8b45a | 180 | { |
38f7147c | 181 | struct eth_header *eth; |
7cb57d10 | 182 | struct arp_eth_header *arp; |
b9e8b45a | 183 | |
cf62fa4c PS |
184 | dp_packet_clear(b); |
185 | dp_packet_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN | |
7cb57d10 | 186 | + ARP_ETH_HEADER_LEN); |
cf62fa4c PS |
187 | dp_packet_reserve(b, 2 + VLAN_HEADER_LEN); |
188 | eth = dp_packet_put_uninit(b, sizeof *eth); | |
74ff3298 JR |
189 | eth->eth_dst = eth_addr_broadcast; |
190 | eth->eth_src = eth_src; | |
38f7147c EJ |
191 | eth->eth_type = htons(ETH_TYPE_RARP); |
192 | ||
cf62fa4c | 193 | arp = dp_packet_put_uninit(b, sizeof *arp); |
7cb57d10 EJ |
194 | arp->ar_hrd = htons(ARP_HRD_ETHERNET); |
195 | arp->ar_pro = htons(ARP_PRO_IP); | |
196 | arp->ar_hln = sizeof arp->ar_sha; | |
197 | arp->ar_pln = sizeof arp->ar_spa; | |
198 | arp->ar_op = htons(ARP_OP_RARP); | |
74ff3298 | 199 | arp->ar_sha = eth_src; |
7c457c33 | 200 | put_16aligned_be32(&arp->ar_spa, htonl(0)); |
74ff3298 | 201 | arp->ar_tha = eth_src; |
7c457c33 | 202 | put_16aligned_be32(&arp->ar_tpa, htonl(0)); |
cf3b7538 | 203 | |
82eb5b0a | 204 | dp_packet_reset_offsets(b); |
cf62fa4c | 205 | dp_packet_set_l3(b, arp); |
2482b0b0 | 206 | b->packet_type = htonl(PT_ETH); |
b9e8b45a | 207 | } |
d31f1109 | 208 | |
d9065a90 | 209 | /* Insert VLAN header according to given TCI. Packet passed must be Ethernet |
2f4ca41b | 210 | * packet. Ignores the CFI bit of 'tci' using 0 instead. |
7c66b273 | 211 | * |
cf3b7538 | 212 | * Also adjusts the layer offsets accordingly. */ |
7c66b273 | 213 | void |
cf62fa4c | 214 | eth_push_vlan(struct dp_packet *packet, ovs_be16 tpid, ovs_be16 tci) |
7c66b273 | 215 | { |
7c66b273 BP |
216 | struct vlan_eth_header *veh; |
217 | ||
d9065a90 | 218 | /* Insert new 802.1Q header. */ |
cf62fa4c | 219 | veh = dp_packet_resize_l2(packet, VLAN_HEADER_LEN); |
437d0d22 JR |
220 | memmove(veh, (char *)veh + VLAN_HEADER_LEN, 2 * ETH_ADDR_LEN); |
221 | veh->veth_type = tpid; | |
222 | veh->veth_tci = tci & htons(~VLAN_CFI); | |
7c66b273 BP |
223 | } |
224 | ||
f4ebc25e BP |
225 | /* Removes outermost VLAN header (if any is present) from 'packet'. |
226 | * | |
d6943394 TH |
227 | * 'packet->l2_5' should initially point to 'packet''s outer-most VLAN header |
228 | * or may be NULL if there are no VLAN headers. */ | |
f4ebc25e | 229 | void |
cf62fa4c | 230 | eth_pop_vlan(struct dp_packet *packet) |
f4ebc25e | 231 | { |
2482b0b0 | 232 | struct vlan_eth_header *veh = dp_packet_eth(packet); |
437d0d22 | 233 | |
cf62fa4c | 234 | if (veh && dp_packet_size(packet) >= sizeof *veh |
d6943394 | 235 | && eth_type_vlan(veh->veth_type)) { |
f4ebc25e | 236 | |
437d0d22 | 237 | memmove((char *)veh + VLAN_HEADER_LEN, veh, 2 * ETH_ADDR_LEN); |
cf62fa4c | 238 | dp_packet_resize_l2(packet, -VLAN_HEADER_LEN); |
f4ebc25e BP |
239 | } |
240 | } | |
241 | ||
88fc5281 JS |
242 | /* Push Ethernet header onto 'packet' assuming it is layer 3 */ |
243 | void | |
244 | push_eth(struct dp_packet *packet, const struct eth_addr *dst, | |
245 | const struct eth_addr *src) | |
246 | { | |
247 | struct eth_header *eh; | |
248 | ||
940ac2ce | 249 | ovs_assert(!dp_packet_is_eth(packet)); |
88fc5281 JS |
250 | eh = dp_packet_resize_l2(packet, ETH_HEADER_LEN); |
251 | eh->eth_dst = *dst; | |
252 | eh->eth_src = *src; | |
253 | eh->eth_type = pt_ns_type_be(packet->packet_type); | |
254 | packet->packet_type = htonl(PT_ETH); | |
255 | } | |
256 | ||
257 | /* Removes Ethernet header, including VLAN header, from 'packet'. | |
258 | * | |
259 | * Previous to calling this function, 'ofpbuf_l3(packet)' must not be NULL */ | |
260 | void | |
261 | pop_eth(struct dp_packet *packet) | |
262 | { | |
263 | char *l2_5 = dp_packet_l2_5(packet); | |
264 | char *l3 = dp_packet_l3(packet); | |
265 | ovs_be16 ethertype; | |
266 | int increment; | |
267 | ||
940ac2ce | 268 | ovs_assert(dp_packet_is_eth(packet)); |
88fc5281 JS |
269 | ovs_assert(l3 != NULL); |
270 | ||
271 | if (l2_5) { | |
272 | increment = packet->l2_5_ofs; | |
273 | ethertype = *(ALIGNED_CAST(ovs_be16 *, (l2_5 - 2))); | |
274 | } else { | |
275 | increment = packet->l3_ofs; | |
276 | ethertype = *(ALIGNED_CAST(ovs_be16 *, (l3 - 2))); | |
277 | } | |
278 | ||
279 | dp_packet_resize_l2(packet, -increment); | |
280 | packet->packet_type = PACKET_TYPE_BE(OFPHTN_ETHERTYPE, ntohs(ethertype)); | |
281 | } | |
282 | ||
b02475c5 | 283 | /* Set ethertype of the packet. */ |
56b02633 | 284 | static void |
cf62fa4c | 285 | set_ethertype(struct dp_packet *packet, ovs_be16 eth_type) |
b02475c5 | 286 | { |
2482b0b0 | 287 | struct eth_header *eh = dp_packet_eth(packet); |
cf3b7538 JR |
288 | |
289 | if (!eh) { | |
290 | return; | |
291 | } | |
b02475c5 | 292 | |
d6943394 | 293 | if (eth_type_vlan(eh->eth_type)) { |
b02475c5 | 294 | ovs_be16 *p; |
cf62fa4c | 295 | char *l2_5 = dp_packet_l2_5(packet); |
437d0d22 | 296 | |
db5a1019 | 297 | p = ALIGNED_CAST(ovs_be16 *, |
cf62fa4c | 298 | (l2_5 ? l2_5 : (char *)dp_packet_l3(packet)) - 2); |
b02475c5 SH |
299 | *p = eth_type; |
300 | } else { | |
301 | eh->eth_type = eth_type; | |
302 | } | |
303 | } | |
304 | ||
cf62fa4c | 305 | static bool is_mpls(struct dp_packet *packet) |
b02475c5 | 306 | { |
437d0d22 | 307 | return packet->l2_5_ofs != UINT16_MAX; |
b02475c5 SH |
308 | } |
309 | ||
310 | /* Set time to live (TTL) of an MPLS label stack entry (LSE). */ | |
b676167a | 311 | void |
b02475c5 SH |
312 | set_mpls_lse_ttl(ovs_be32 *lse, uint8_t ttl) |
313 | { | |
314 | *lse &= ~htonl(MPLS_TTL_MASK); | |
315 | *lse |= htonl((ttl << MPLS_TTL_SHIFT) & MPLS_TTL_MASK); | |
316 | } | |
317 | ||
318 | /* Set traffic class (TC) of an MPLS label stack entry (LSE). */ | |
319 | void | |
320 | set_mpls_lse_tc(ovs_be32 *lse, uint8_t tc) | |
321 | { | |
322 | *lse &= ~htonl(MPLS_TC_MASK); | |
323 | *lse |= htonl((tc << MPLS_TC_SHIFT) & MPLS_TC_MASK); | |
324 | } | |
325 | ||
326 | /* Set label of an MPLS label stack entry (LSE). */ | |
327 | void | |
328 | set_mpls_lse_label(ovs_be32 *lse, ovs_be32 label) | |
329 | { | |
330 | *lse &= ~htonl(MPLS_LABEL_MASK); | |
331 | *lse |= htonl((ntohl(label) << MPLS_LABEL_SHIFT) & MPLS_LABEL_MASK); | |
332 | } | |
333 | ||
334 | /* Set bottom of stack (BoS) bit of an MPLS label stack entry (LSE). */ | |
335 | void | |
336 | set_mpls_lse_bos(ovs_be32 *lse, uint8_t bos) | |
337 | { | |
338 | *lse &= ~htonl(MPLS_BOS_MASK); | |
339 | *lse |= htonl((bos << MPLS_BOS_SHIFT) & MPLS_BOS_MASK); | |
340 | } | |
341 | ||
342 | /* Compose an MPLS label stack entry (LSE) from its components: | |
343 | * label, traffic class (TC), time to live (TTL) and | |
344 | * bottom of stack (BoS) bit. */ | |
345 | ovs_be32 | |
346 | set_mpls_lse_values(uint8_t ttl, uint8_t tc, uint8_t bos, ovs_be32 label) | |
347 | { | |
348 | ovs_be32 lse = htonl(0); | |
349 | set_mpls_lse_ttl(&lse, ttl); | |
350 | set_mpls_lse_tc(&lse, tc); | |
351 | set_mpls_lse_bos(&lse, bos); | |
352 | set_mpls_lse_label(&lse, label); | |
353 | return lse; | |
354 | } | |
355 | ||
b02475c5 SH |
356 | /* Set MPLS label stack entry to outermost MPLS header.*/ |
357 | void | |
cf62fa4c | 358 | set_mpls_lse(struct dp_packet *packet, ovs_be32 mpls_lse) |
b02475c5 | 359 | { |
b02475c5 SH |
360 | /* Packet type should be MPLS to set label stack entry. */ |
361 | if (is_mpls(packet)) { | |
cf62fa4c | 362 | struct mpls_hdr *mh = dp_packet_l2_5(packet); |
437d0d22 | 363 | |
b02475c5 | 364 | /* Update mpls label stack entry. */ |
5fa008d4 | 365 | put_16aligned_be32(&mh->mpls_lse, mpls_lse); |
b02475c5 SH |
366 | } |
367 | } | |
368 | ||
898dcef1 | 369 | /* Push MPLS label stack entry 'lse' onto 'packet' as the outermost MPLS |
b02475c5 SH |
370 | * header. If 'packet' does not already have any MPLS labels, then its |
371 | * Ethertype is changed to 'ethtype' (which must be an MPLS Ethertype). */ | |
372 | void | |
cf62fa4c | 373 | push_mpls(struct dp_packet *packet, ovs_be16 ethtype, ovs_be32 lse) |
b02475c5 | 374 | { |
437d0d22 JR |
375 | char * header; |
376 | size_t len; | |
b02475c5 SH |
377 | |
378 | if (!eth_type_mpls(ethtype)) { | |
379 | return; | |
380 | } | |
381 | ||
382 | if (!is_mpls(packet)) { | |
437d0d22 JR |
383 | /* Set MPLS label stack offset. */ |
384 | packet->l2_5_ofs = packet->l3_ofs; | |
b02475c5 SH |
385 | } |
386 | ||
437d0d22 JR |
387 | set_ethertype(packet, ethtype); |
388 | ||
b02475c5 | 389 | /* Push new MPLS shim header onto packet. */ |
437d0d22 | 390 | len = packet->l2_5_ofs; |
cf62fa4c | 391 | header = dp_packet_resize_l2_5(packet, MPLS_HLEN); |
437d0d22 JR |
392 | memmove(header, header + MPLS_HLEN, len); |
393 | memcpy(header + len, &lse, sizeof lse); | |
594570ea DB |
394 | |
395 | pkt_metadata_init_conn(&packet->md); | |
b02475c5 SH |
396 | } |
397 | ||
398 | /* If 'packet' is an MPLS packet, removes its outermost MPLS label stack entry. | |
399 | * If the label that was removed was the only MPLS label, changes 'packet''s | |
400 | * Ethertype to 'ethtype' (which ordinarily should not be an MPLS | |
401 | * Ethertype). */ | |
402 | void | |
cf62fa4c | 403 | pop_mpls(struct dp_packet *packet, ovs_be16 ethtype) |
b02475c5 | 404 | { |
b02475c5 | 405 | if (is_mpls(packet)) { |
cf62fa4c | 406 | struct mpls_hdr *mh = dp_packet_l2_5(packet); |
437d0d22 JR |
407 | size_t len = packet->l2_5_ofs; |
408 | ||
799a91bb | 409 | set_ethertype(packet, ethtype); |
5fa008d4 | 410 | if (get_16aligned_be32(&mh->mpls_lse) & htonl(MPLS_BOS_MASK)) { |
cf62fa4c | 411 | dp_packet_set_l2_5(packet, NULL); |
b02475c5 SH |
412 | } |
413 | /* Shift the l2 header forward. */ | |
cf62fa4c PS |
414 | memmove((char*)dp_packet_data(packet) + MPLS_HLEN, dp_packet_data(packet), len); |
415 | dp_packet_resize_l2_5(packet, -MPLS_HLEN); | |
f92bba16 NK |
416 | |
417 | /* Invalidate offload flags as they are not valid after | |
418 | * decapsulation of MPLS header. */ | |
419 | dp_packet_reset_offload(packet); | |
b02475c5 SH |
420 | } |
421 | } | |
422 | ||
1fc11c59 | 423 | void |
f59cb331 | 424 | push_nsh(struct dp_packet *packet, const struct nsh_hdr *nsh_hdr_src) |
1fc11c59 JS |
425 | { |
426 | struct nsh_hdr *nsh; | |
f59cb331 | 427 | size_t length = nsh_hdr_len(nsh_hdr_src); |
1fc11c59 JS |
428 | uint8_t next_proto; |
429 | ||
430 | switch (ntohl(packet->packet_type)) { | |
431 | case PT_ETH: | |
432 | next_proto = NSH_P_ETHERNET; | |
433 | break; | |
434 | case PT_IPV4: | |
435 | next_proto = NSH_P_IPV4; | |
436 | break; | |
437 | case PT_IPV6: | |
438 | next_proto = NSH_P_IPV6; | |
439 | break; | |
440 | case PT_NSH: | |
441 | next_proto = NSH_P_NSH; | |
442 | break; | |
443 | default: | |
444 | OVS_NOT_REACHED(); | |
445 | } | |
446 | ||
447 | nsh = (struct nsh_hdr *) dp_packet_push_uninit(packet, length); | |
f59cb331 | 448 | memcpy(nsh, nsh_hdr_src, length); |
1fc11c59 | 449 | nsh->next_proto = next_proto; |
1fc11c59 JS |
450 | packet->packet_type = htonl(PT_NSH); |
451 | dp_packet_reset_offsets(packet); | |
452 | packet->l3_ofs = 0; | |
453 | } | |
454 | ||
455 | bool | |
f59cb331 | 456 | pop_nsh(struct dp_packet *packet) |
1fc11c59 JS |
457 | { |
458 | struct nsh_hdr *nsh = (struct nsh_hdr *) dp_packet_l3(packet); | |
459 | size_t length; | |
460 | uint32_t next_pt; | |
461 | ||
462 | if (packet->packet_type == htonl(PT_NSH) && nsh) { | |
463 | switch (nsh->next_proto) { | |
464 | case NSH_P_ETHERNET: | |
465 | next_pt = PT_ETH; | |
466 | break; | |
467 | case NSH_P_IPV4: | |
468 | next_pt = PT_IPV4; | |
469 | break; | |
470 | case NSH_P_IPV6: | |
471 | next_pt = PT_IPV6; | |
472 | break; | |
473 | case NSH_P_NSH: | |
474 | next_pt = PT_NSH; | |
475 | break; | |
476 | default: | |
477 | /* Unknown inner packet type. Drop packet. */ | |
478 | return false; | |
479 | } | |
480 | ||
481 | length = nsh_hdr_len(nsh); | |
482 | dp_packet_reset_packet(packet, length); | |
483 | packet->packet_type = htonl(next_pt); | |
484 | /* Packet must be recirculated for further processing. */ | |
485 | } | |
486 | return true; | |
487 | } | |
488 | ||
e22f1753 BP |
489 | /* Converts hex digits in 'hex' to an Ethernet packet in '*packetp'. The |
490 | * caller must free '*packetp'. On success, returns NULL. On failure, returns | |
bb622f82 BP |
491 | * an error message and stores NULL in '*packetp'. |
492 | * | |
493 | * Aligns the L3 header of '*packetp' on a 32-bit boundary. */ | |
e22f1753 | 494 | const char * |
cf62fa4c | 495 | eth_from_hex(const char *hex, struct dp_packet **packetp) |
e22f1753 | 496 | { |
cf62fa4c | 497 | struct dp_packet *packet; |
e22f1753 | 498 | |
bb622f82 | 499 | /* Use 2 bytes of headroom to 32-bit align the L3 header. */ |
cf62fa4c | 500 | packet = *packetp = dp_packet_new_with_headroom(strlen(hex) / 2, 2); |
e22f1753 | 501 | |
cf62fa4c PS |
502 | if (dp_packet_put_hex(packet, hex, NULL)[0] != '\0') { |
503 | dp_packet_delete(packet); | |
e22f1753 BP |
504 | *packetp = NULL; |
505 | return "Trailing garbage in packet data"; | |
506 | } | |
507 | ||
cf62fa4c PS |
508 | if (dp_packet_size(packet) < ETH_HEADER_LEN) { |
509 | dp_packet_delete(packet); | |
e22f1753 BP |
510 | *packetp = NULL; |
511 | return "Packet data too short for Ethernet"; | |
512 | } | |
513 | ||
514 | return NULL; | |
515 | } | |
516 | ||
3b4d8ad3 | 517 | void |
74ff3298 JR |
518 | eth_format_masked(const struct eth_addr eth, |
519 | const struct eth_addr *mask, struct ds *s) | |
3b4d8ad3 JS |
520 | { |
521 | ds_put_format(s, ETH_ADDR_FMT, ETH_ADDR_ARGS(eth)); | |
74ff3298 JR |
522 | if (mask && !eth_mask_is_exact(*mask)) { |
523 | ds_put_format(s, "/"ETH_ADDR_FMT, ETH_ADDR_ARGS(*mask)); | |
3b4d8ad3 JS |
524 | } |
525 | } | |
526 | ||
aad29cd1 | 527 | /* Given the IP netmask 'netmask', returns the number of bits of the IP address |
c08201d6 BP |
528 | * that it specifies, that is, the number of 1-bits in 'netmask'. |
529 | * | |
530 | * If 'netmask' is not a CIDR netmask (see ip_is_cidr()), the return value will | |
531 | * still be in the valid range but isn't otherwise meaningful. */ | |
aad29cd1 BP |
532 | int |
533 | ip_count_cidr_bits(ovs_be32 netmask) | |
534 | { | |
d578065e | 535 | return 32 - ctz32(ntohl(netmask)); |
aad29cd1 BP |
536 | } |
537 | ||
538 | void | |
539 | ip_format_masked(ovs_be32 ip, ovs_be32 mask, struct ds *s) | |
540 | { | |
ed36537e | 541 | ds_put_format(s, IP_FMT, IP_ARGS(ip)); |
b8266395 | 542 | if (mask != OVS_BE32_MAX) { |
aad29cd1 BP |
543 | if (ip_is_cidr(mask)) { |
544 | ds_put_format(s, "/%d", ip_count_cidr_bits(mask)); | |
545 | } else { | |
ed36537e | 546 | ds_put_format(s, "/"IP_FMT, IP_ARGS(mask)); |
aad29cd1 BP |
547 | } |
548 | } | |
549 | } | |
550 | ||
2b02db1b BP |
551 | /* Parses string 's', which must be an IP address. Stores the IP address into |
552 | * '*ip'. Returns true if successful, otherwise false. */ | |
553 | bool | |
554 | ip_parse(const char *s, ovs_be32 *ip) | |
555 | { | |
556 | return inet_pton(AF_INET, s, ip) == 1; | |
557 | } | |
558 | ||
e2bfcad6 | 559 | /* Parses string 's', which must be an IP address with a port number |
560 | * with ":" as a separator (e.g.: 192.168.1.2:80). | |
fab4e043 | 561 | * Stores the IP address into '*ip' and port number to '*port'. |
562 | * | |
563 | * Returns NULL if successful, otherwise an error message that the caller must | |
564 | * free(). */ | |
e2bfcad6 | 565 | char * OVS_WARN_UNUSED_RESULT |
566 | ip_parse_port(const char *s, ovs_be32 *ip, ovs_be16 *port) | |
567 | { | |
568 | int n = 0; | |
fab4e043 | 569 | if (ovs_scan(s, IP_PORT_SCAN_FMT"%n", IP_PORT_SCAN_ARGS(ip, port), &n) |
570 | && !s[n]) { | |
571 | return NULL; | |
e2bfcad6 | 572 | } |
573 | ||
fab4e043 | 574 | return xasprintf("%s: invalid IP address or port number", s); |
e2bfcad6 | 575 | } |
576 | ||
61440451 | 577 | /* Parses string 's', which must be an IP address with an optional netmask or |
7dc88496 NS |
578 | * CIDR prefix length. Stores the IP address into '*ip', netmask into '*mask', |
579 | * (255.255.255.255, if 's' lacks a netmask), and number of scanned characters | |
580 | * into '*n'. | |
61440451 BP |
581 | * |
582 | * Returns NULL if successful, otherwise an error message that the caller must | |
583 | * free(). */ | |
584 | char * OVS_WARN_UNUSED_RESULT | |
7dc88496 NS |
585 | ip_parse_masked_len(const char *s, int *n, ovs_be32 *ip, |
586 | ovs_be32 *mask) | |
61440451 BP |
587 | { |
588 | int prefix; | |
589 | ||
7dc88496 NS |
590 | if (ovs_scan_len(s, n, IP_SCAN_FMT"/"IP_SCAN_FMT, |
591 | IP_SCAN_ARGS(ip), IP_SCAN_ARGS(mask))) { | |
61440451 | 592 | /* OK. */ |
7dc88496 NS |
593 | } else if (ovs_scan_len(s, n, IP_SCAN_FMT"/%d", |
594 | IP_SCAN_ARGS(ip), &prefix)) { | |
4c9a736e JP |
595 | if (prefix < 0 || prefix > 32) { |
596 | return xasprintf("%s: IPv4 network prefix bits not between 0 and " | |
597 | "32, inclusive", s); | |
61440451 BP |
598 | } |
599 | *mask = be32_prefix_mask(prefix); | |
7dc88496 | 600 | } else if (ovs_scan_len(s, n, IP_SCAN_FMT, IP_SCAN_ARGS(ip))) { |
61440451 BP |
601 | *mask = OVS_BE32_MAX; |
602 | } else { | |
603 | return xasprintf("%s: invalid IP address", s); | |
604 | } | |
605 | return NULL; | |
606 | } | |
aad29cd1 | 607 | |
7dc88496 NS |
608 | /* This function is similar to ip_parse_masked_len(), but doesn't return the |
609 | * number of scanned characters and expects 's' to end after the ip/(optional) | |
610 | * mask. | |
611 | * | |
612 | * Returns NULL if successful, otherwise an error message that the caller must | |
613 | * free(). */ | |
2b02db1b | 614 | char * OVS_WARN_UNUSED_RESULT |
7dc88496 NS |
615 | ip_parse_masked(const char *s, ovs_be32 *ip, ovs_be32 *mask) |
616 | { | |
617 | int n = 0; | |
618 | ||
619 | char *error = ip_parse_masked_len(s, &n, ip, mask); | |
620 | if (!error && s[n]) { | |
621 | return xasprintf("%s: invalid IP address", s); | |
622 | } | |
623 | return error; | |
624 | } | |
625 | ||
626 | /* Similar to ip_parse_masked_len(), but the mask, if present, must be a CIDR | |
627 | * mask and is returned as a prefix len in '*plen'. */ | |
628 | char * OVS_WARN_UNUSED_RESULT | |
629 | ip_parse_cidr_len(const char *s, int *n, ovs_be32 *ip, unsigned int *plen) | |
2b02db1b BP |
630 | { |
631 | ovs_be32 mask; | |
632 | char *error; | |
633 | ||
7dc88496 | 634 | error = ip_parse_masked_len(s, n, ip, &mask); |
2b02db1b BP |
635 | if (error) { |
636 | return error; | |
637 | } | |
638 | ||
639 | if (!ip_is_cidr(mask)) { | |
640 | return xasprintf("%s: CIDR network required", s); | |
641 | } | |
642 | *plen = ip_count_cidr_bits(mask); | |
643 | return NULL; | |
644 | } | |
645 | ||
7dc88496 NS |
646 | /* Similar to ip_parse_cidr_len(), but doesn't return the number of scanned |
647 | * characters and expects 's' to be NULL terminated at the end of the | |
648 | * ip/(optional) cidr. */ | |
649 | char * OVS_WARN_UNUSED_RESULT | |
650 | ip_parse_cidr(const char *s, ovs_be32 *ip, unsigned int *plen) | |
651 | { | |
652 | int n = 0; | |
653 | ||
654 | char *error = ip_parse_cidr_len(s, &n, ip, plen); | |
655 | if (!error && s[n]) { | |
656 | return xasprintf("%s: invalid IP address", s); | |
657 | } | |
658 | return error; | |
659 | } | |
660 | ||
2b02db1b BP |
661 | /* Parses string 's', which must be an IPv6 address. Stores the IPv6 address |
662 | * into '*ip'. Returns true if successful, otherwise false. */ | |
663 | bool | |
664 | ipv6_parse(const char *s, struct in6_addr *ip) | |
665 | { | |
666 | return inet_pton(AF_INET6, s, ip) == 1; | |
667 | } | |
668 | ||
669 | /* Parses string 's', which must be an IPv6 address with an optional netmask or | |
670 | * CIDR prefix length. Stores the IPv6 address into '*ip' and the netmask into | |
7dc88496 NS |
671 | * '*mask' (if 's' does not contain a netmask, all-one-bits is assumed), and |
672 | * number of scanned characters into '*n'. | |
2b02db1b BP |
673 | * |
674 | * Returns NULL if successful, otherwise an error message that the caller must | |
675 | * free(). */ | |
676 | char * OVS_WARN_UNUSED_RESULT | |
7dc88496 NS |
677 | ipv6_parse_masked_len(const char *s, int *n, struct in6_addr *ip, |
678 | struct in6_addr *mask) | |
2b02db1b BP |
679 | { |
680 | char ipv6_s[IPV6_SCAN_LEN + 1]; | |
681 | int prefix; | |
2b02db1b | 682 | |
7dc88496 NS |
683 | if (ovs_scan_len(s, n, " "IPV6_SCAN_FMT, ipv6_s) |
684 | && ipv6_parse(ipv6_s, ip)) { | |
685 | if (ovs_scan_len(s, n, "/%d", &prefix)) { | |
4c9a736e | 686 | if (prefix < 0 || prefix > 128) { |
2b02db1b | 687 | return xasprintf("%s: IPv6 network prefix bits not between 0 " |
4c9a736e | 688 | "and 128, inclusive", s); |
2b02db1b BP |
689 | } |
690 | *mask = ipv6_create_mask(prefix); | |
7dc88496 NS |
691 | } else if (ovs_scan_len(s, n, "/"IPV6_SCAN_FMT, ipv6_s)) { |
692 | if (!ipv6_parse(ipv6_s, mask)) { | |
693 | return xasprintf("%s: Invalid IPv6 mask", s); | |
694 | } | |
2b02db1b BP |
695 | /* OK. */ |
696 | } else { | |
7dc88496 NS |
697 | /* OK. No mask. */ |
698 | *mask = in6addr_exact; | |
2b02db1b BP |
699 | } |
700 | return NULL; | |
701 | } | |
702 | return xasprintf("%s: invalid IPv6 address", s); | |
703 | } | |
704 | ||
7dc88496 NS |
705 | /* This function is similar to ipv6_parse_masked_len(), but doesn't return the |
706 | * number of scanned characters and expects 's' to end following the | |
707 | * ipv6/(optional) mask. */ | |
708 | char * OVS_WARN_UNUSED_RESULT | |
709 | ipv6_parse_masked(const char *s, struct in6_addr *ip, struct in6_addr *mask) | |
710 | { | |
711 | int n = 0; | |
712 | ||
713 | char *error = ipv6_parse_masked_len(s, &n, ip, mask); | |
714 | if (!error && s[n]) { | |
715 | return xasprintf("%s: invalid IPv6 address", s); | |
716 | } | |
717 | return error; | |
718 | } | |
719 | ||
720 | /* Similar to ipv6_parse_masked_len(), but the mask, if present, must be a CIDR | |
2b02db1b BP |
721 | * mask and is returned as a prefix length in '*plen'. */ |
722 | char * OVS_WARN_UNUSED_RESULT | |
7dc88496 NS |
723 | ipv6_parse_cidr_len(const char *s, int *n, struct in6_addr *ip, |
724 | unsigned int *plen) | |
2b02db1b BP |
725 | { |
726 | struct in6_addr mask; | |
727 | char *error; | |
728 | ||
7dc88496 | 729 | error = ipv6_parse_masked_len(s, n, ip, &mask); |
2b02db1b BP |
730 | if (error) { |
731 | return error; | |
732 | } | |
733 | ||
734 | if (!ipv6_is_cidr(&mask)) { | |
735 | return xasprintf("%s: IPv6 CIDR network required", s); | |
736 | } | |
737 | *plen = ipv6_count_cidr_bits(&mask); | |
738 | return NULL; | |
739 | } | |
740 | ||
7dc88496 NS |
741 | /* Similar to ipv6_parse_cidr_len(), but doesn't return the number of scanned |
742 | * characters and expects 's' to end after the ipv6/(optional) cidr. */ | |
743 | char * OVS_WARN_UNUSED_RESULT | |
744 | ipv6_parse_cidr(const char *s, struct in6_addr *ip, unsigned int *plen) | |
745 | { | |
746 | int n = 0; | |
747 | ||
748 | char *error = ipv6_parse_cidr_len(s, &n, ip, plen); | |
749 | if (!error && s[n]) { | |
750 | return xasprintf("%s: invalid IPv6 address", s); | |
751 | } | |
752 | return error; | |
753 | } | |
754 | ||
2b02db1b BP |
755 | /* Stores the string representation of the IPv6 address 'addr' into the |
756 | * character array 'addr_str', which must be at least INET6_ADDRSTRLEN | |
757 | * bytes long. */ | |
d31f1109 | 758 | void |
ac6d120f | 759 | ipv6_format_addr(const struct in6_addr *addr, struct ds *s) |
d31f1109 | 760 | { |
aad29cd1 BP |
761 | char *dst; |
762 | ||
ac6d120f | 763 | ds_reserve(s, s->length + INET6_ADDRSTRLEN); |
aad29cd1 | 764 | |
ac6d120f JP |
765 | dst = s->string + s->length; |
766 | inet_ntop(AF_INET6, addr, dst, INET6_ADDRSTRLEN); | |
767 | s->length += strlen(dst); | |
aad29cd1 | 768 | } |
d31f1109 | 769 | |
9ac0aada JR |
770 | /* Same as print_ipv6_addr, but optionally encloses the address in square |
771 | * brackets. */ | |
772 | void | |
773 | ipv6_format_addr_bracket(const struct in6_addr *addr, struct ds *s, | |
774 | bool bracket) | |
775 | { | |
776 | if (bracket) { | |
777 | ds_put_char(s, '['); | |
778 | } | |
779 | ipv6_format_addr(addr, s); | |
780 | if (bracket) { | |
781 | ds_put_char(s, ']'); | |
782 | } | |
783 | } | |
784 | ||
964a4d5f | 785 | void |
ac6d120f | 786 | ipv6_format_mapped(const struct in6_addr *addr, struct ds *s) |
964a4d5f TLSC |
787 | { |
788 | if (IN6_IS_ADDR_V4MAPPED(addr)) { | |
789 | ds_put_format(s, IP_FMT, addr->s6_addr[12], addr->s6_addr[13], | |
790 | addr->s6_addr[14], addr->s6_addr[15]); | |
791 | } else { | |
ac6d120f | 792 | ipv6_format_addr(addr, s); |
964a4d5f TLSC |
793 | } |
794 | } | |
795 | ||
aad29cd1 | 796 | void |
ac6d120f JP |
797 | ipv6_format_masked(const struct in6_addr *addr, const struct in6_addr *mask, |
798 | struct ds *s) | |
aad29cd1 | 799 | { |
ac6d120f | 800 | ipv6_format_addr(addr, s); |
aad29cd1 BP |
801 | if (mask && !ipv6_mask_is_exact(mask)) { |
802 | if (ipv6_is_cidr(mask)) { | |
803 | int cidr_bits = ipv6_count_cidr_bits(mask); | |
804 | ds_put_format(s, "/%d", cidr_bits); | |
805 | } else { | |
806 | ds_put_char(s, '/'); | |
ac6d120f | 807 | ipv6_format_addr(mask, s); |
aad29cd1 BP |
808 | } |
809 | } | |
d31f1109 JP |
810 | } |
811 | ||
bed610e8 TLSC |
812 | /* Stores the string representation of the IPv6 address 'addr' into the |
813 | * character array 'addr_str', which must be at least INET6_ADDRSTRLEN | |
814 | * bytes long. If addr is IPv4-mapped, store an IPv4 dotted-decimal string. */ | |
815 | const char * | |
816 | ipv6_string_mapped(char *addr_str, const struct in6_addr *addr) | |
817 | { | |
818 | ovs_be32 ip; | |
819 | ip = in6_addr_get_mapped_ipv4(addr); | |
820 | if (ip) { | |
821 | return inet_ntop(AF_INET, &ip, addr_str, INET6_ADDRSTRLEN); | |
822 | } else { | |
823 | return inet_ntop(AF_INET6, addr, addr_str, INET6_ADDRSTRLEN); | |
824 | } | |
825 | } | |
826 | ||
d31f1109 | 827 | #ifdef s6_addr32 |
b0ad27f3 JP |
828 | #define s6_addrX s6_addr32 |
829 | #define IPV6_FOR_EACH(VAR) for (int VAR = 0; VAR < 4; VAR++) | |
d31f1109 | 830 | #else |
b0ad27f3 JP |
831 | #define s6_addrX s6_addr |
832 | #define IPV6_FOR_EACH(VAR) for (int VAR = 0; VAR < 16; VAR++) | |
d31f1109 JP |
833 | #endif |
834 | ||
b0ad27f3 JP |
835 | struct in6_addr |
836 | ipv6_addr_bitand(const struct in6_addr *a, const struct in6_addr *b) | |
837 | { | |
838 | struct in6_addr dst; | |
839 | IPV6_FOR_EACH (i) { | |
840 | dst.s6_addrX[i] = a->s6_addrX[i] & b->s6_addrX[i]; | |
841 | } | |
842 | return dst; | |
843 | } | |
844 | ||
845 | struct in6_addr | |
846 | ipv6_addr_bitxor(const struct in6_addr *a, const struct in6_addr *b) | |
847 | { | |
848 | struct in6_addr dst; | |
849 | IPV6_FOR_EACH (i) { | |
850 | dst.s6_addrX[i] = a->s6_addrX[i] ^ b->s6_addrX[i]; | |
851 | } | |
852 | return dst; | |
853 | } | |
854 | ||
855 | bool | |
856 | ipv6_is_zero(const struct in6_addr *a) | |
857 | { | |
858 | IPV6_FOR_EACH (i) { | |
859 | if (a->s6_addrX[i]) { | |
860 | return false; | |
861 | } | |
862 | } | |
863 | return true; | |
d31f1109 JP |
864 | } |
865 | ||
866 | /* Returns an in6_addr consisting of 'mask' high-order 1-bits and 128-N | |
867 | * low-order 0-bits. */ | |
868 | struct in6_addr | |
869 | ipv6_create_mask(int mask) | |
870 | { | |
871 | struct in6_addr netmask; | |
872 | uint8_t *netmaskp = &netmask.s6_addr[0]; | |
873 | ||
874 | memset(&netmask, 0, sizeof netmask); | |
875 | while (mask > 8) { | |
876 | *netmaskp = 0xff; | |
877 | netmaskp++; | |
878 | mask -= 8; | |
879 | } | |
880 | ||
881 | if (mask) { | |
882 | *netmaskp = 0xff << (8 - mask); | |
883 | } | |
884 | ||
885 | return netmask; | |
886 | } | |
887 | ||
aad29cd1 BP |
888 | /* Given the IPv6 netmask 'netmask', returns the number of bits of the IPv6 |
889 | * address that it specifies, that is, the number of 1-bits in 'netmask'. | |
ff0b06ee BP |
890 | * 'netmask' must be a CIDR netmask (see ipv6_is_cidr()). |
891 | * | |
892 | * If 'netmask' is not a CIDR netmask (see ipv6_is_cidr()), the return value | |
893 | * will still be in the valid range but isn't otherwise meaningful. */ | |
d31f1109 JP |
894 | int |
895 | ipv6_count_cidr_bits(const struct in6_addr *netmask) | |
896 | { | |
897 | int i; | |
898 | int count = 0; | |
899 | const uint8_t *netmaskp = &netmask->s6_addr[0]; | |
900 | ||
d31f1109 JP |
901 | for (i=0; i<16; i++) { |
902 | if (netmaskp[i] == 0xff) { | |
903 | count += 8; | |
904 | } else { | |
905 | uint8_t nm; | |
906 | ||
907 | for(nm = netmaskp[i]; nm; nm <<= 1) { | |
908 | count++; | |
909 | } | |
910 | break; | |
911 | } | |
912 | ||
913 | } | |
914 | ||
915 | return count; | |
916 | } | |
917 | ||
d31f1109 JP |
918 | /* Returns true if 'netmask' is a CIDR netmask, that is, if it consists of N |
919 | * high-order 1-bits and 128-N low-order 0-bits. */ | |
920 | bool | |
921 | ipv6_is_cidr(const struct in6_addr *netmask) | |
922 | { | |
923 | const uint8_t *netmaskp = &netmask->s6_addr[0]; | |
924 | int i; | |
925 | ||
926 | for (i=0; i<16; i++) { | |
927 | if (netmaskp[i] != 0xff) { | |
928 | uint8_t x = ~netmaskp[i]; | |
929 | if (x & (x + 1)) { | |
930 | return false; | |
931 | } | |
932 | while (++i < 16) { | |
933 | if (netmaskp[i]) { | |
934 | return false; | |
935 | } | |
936 | } | |
937 | } | |
938 | } | |
939 | ||
940 | return true; | |
941 | } | |
c25c91fd | 942 | |
5de1bb5c BP |
943 | /* Populates 'b' with an Ethernet II packet headed with the given 'eth_dst', |
944 | * 'eth_src' and 'eth_type' parameters. A payload of 'size' bytes is allocated | |
945 | * in 'b' and returned. This payload may be populated with appropriate | |
cf3b7538 JR |
946 | * information by the caller. Sets 'b''s 'frame' pointer and 'l3' offset to |
947 | * the Ethernet header and payload respectively. Aligns b->l3 on a 32-bit | |
bb622f82 | 948 | * boundary. |
eda1f38d BP |
949 | * |
950 | * The returned packet has enough headroom to insert an 802.1Q VLAN header if | |
951 | * desired. */ | |
40f78b38 | 952 | void * |
74ff3298 JR |
953 | eth_compose(struct dp_packet *b, const struct eth_addr eth_dst, |
954 | const struct eth_addr eth_src, uint16_t eth_type, | |
5de1bb5c | 955 | size_t size) |
c25c91fd | 956 | { |
40f78b38 | 957 | void *data; |
c25c91fd | 958 | struct eth_header *eth; |
c25c91fd | 959 | |
cf62fa4c | 960 | dp_packet_clear(b); |
c25c91fd | 961 | |
bb622f82 BP |
962 | /* The magic 2 here ensures that the L3 header (when it is added later) |
963 | * will be 32-bit aligned. */ | |
cf62fa4c PS |
964 | dp_packet_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN + size); |
965 | dp_packet_reserve(b, 2 + VLAN_HEADER_LEN); | |
966 | eth = dp_packet_put_uninit(b, ETH_HEADER_LEN); | |
c4bee4cb | 967 | data = dp_packet_put_zeros(b, size); |
c25c91fd | 968 | |
74ff3298 JR |
969 | eth->eth_dst = eth_dst; |
970 | eth->eth_src = eth_src; | |
40f78b38 EJ |
971 | eth->eth_type = htons(eth_type); |
972 | ||
2482b0b0 | 973 | b->packet_type = htonl(PT_ETH); |
82eb5b0a | 974 | dp_packet_reset_offsets(b); |
cf62fa4c | 975 | dp_packet_set_l3(b, data); |
75a4ead1 | 976 | |
40f78b38 | 977 | return data; |
07a6cf77 EJ |
978 | } |
979 | ||
fc052306 | 980 | void |
cf62fa4c | 981 | packet_set_ipv4_addr(struct dp_packet *packet, |
7c457c33 | 982 | ovs_16aligned_be32 *addr, ovs_be32 new_addr) |
c97664b3 | 983 | { |
cf62fa4c | 984 | struct ip_header *nh = dp_packet_l3(packet); |
7c457c33 | 985 | ovs_be32 old_addr = get_16aligned_be32(addr); |
cf62fa4c | 986 | size_t l4_size = dp_packet_l4_size(packet); |
c97664b3 | 987 | |
594570ea DB |
988 | pkt_metadata_init_conn(&packet->md); |
989 | ||
5a51b2cd | 990 | if (nh->ip_proto == IPPROTO_TCP && l4_size >= TCP_HEADER_LEN) { |
cf62fa4c | 991 | struct tcp_header *th = dp_packet_l4(packet); |
c97664b3 | 992 | |
7c457c33 | 993 | th->tcp_csum = recalc_csum32(th->tcp_csum, old_addr, new_addr); |
5a51b2cd | 994 | } else if (nh->ip_proto == IPPROTO_UDP && l4_size >= UDP_HEADER_LEN ) { |
cf62fa4c | 995 | struct udp_header *uh = dp_packet_l4(packet); |
c97664b3 EJ |
996 | |
997 | if (uh->udp_csum) { | |
7c457c33 | 998 | uh->udp_csum = recalc_csum32(uh->udp_csum, old_addr, new_addr); |
c97664b3 EJ |
999 | if (!uh->udp_csum) { |
1000 | uh->udp_csum = htons(0xffff); | |
1001 | } | |
1002 | } | |
1003 | } | |
7c457c33 BP |
1004 | nh->ip_csum = recalc_csum32(nh->ip_csum, old_addr, new_addr); |
1005 | put_16aligned_be32(addr, new_addr); | |
c97664b3 EJ |
1006 | } |
1007 | ||
bc7a5acd AA |
1008 | /* Returns true, if packet contains at least one routing header where |
1009 | * segements_left > 0. | |
1010 | * | |
437d0d22 | 1011 | * This function assumes that L3 and L4 offsets are set in the packet. */ |
bc7a5acd | 1012 | static bool |
31a9a584 | 1013 | packet_rh_present(struct dp_packet *packet, uint8_t *nexthdr) |
bc7a5acd | 1014 | { |
4528f34f | 1015 | const struct ovs_16aligned_ip6_hdr *nh; |
bc7a5acd AA |
1016 | size_t len; |
1017 | size_t remaining; | |
cf62fa4c | 1018 | uint8_t *data = dp_packet_l3(packet); |
bc7a5acd | 1019 | |
437d0d22 | 1020 | remaining = packet->l4_ofs - packet->l3_ofs; |
bc7a5acd AA |
1021 | if (remaining < sizeof *nh) { |
1022 | return false; | |
1023 | } | |
4528f34f | 1024 | nh = ALIGNED_CAST(struct ovs_16aligned_ip6_hdr *, data); |
bc7a5acd AA |
1025 | data += sizeof *nh; |
1026 | remaining -= sizeof *nh; | |
31a9a584 | 1027 | *nexthdr = nh->ip6_nxt; |
bc7a5acd AA |
1028 | |
1029 | while (1) { | |
31a9a584 SH |
1030 | if ((*nexthdr != IPPROTO_HOPOPTS) |
1031 | && (*nexthdr != IPPROTO_ROUTING) | |
1032 | && (*nexthdr != IPPROTO_DSTOPTS) | |
1033 | && (*nexthdr != IPPROTO_AH) | |
1034 | && (*nexthdr != IPPROTO_FRAGMENT)) { | |
bc7a5acd AA |
1035 | /* It's either a terminal header (e.g., TCP, UDP) or one we |
1036 | * don't understand. In either case, we're done with the | |
1037 | * packet, so use it to fill in 'nw_proto'. */ | |
1038 | break; | |
1039 | } | |
1040 | ||
1041 | /* We only verify that at least 8 bytes of the next header are | |
1042 | * available, but many of these headers are longer. Ensure that | |
1043 | * accesses within the extension header are within those first 8 | |
1044 | * bytes. All extension headers are required to be at least 8 | |
1045 | * bytes. */ | |
1046 | if (remaining < 8) { | |
1047 | return false; | |
1048 | } | |
1049 | ||
31a9a584 | 1050 | if (*nexthdr == IPPROTO_AH) { |
bc7a5acd AA |
1051 | /* A standard AH definition isn't available, but the fields |
1052 | * we care about are in the same location as the generic | |
1053 | * option header--only the header length is calculated | |
1054 | * differently. */ | |
1055 | const struct ip6_ext *ext_hdr = (struct ip6_ext *)data; | |
1056 | ||
31a9a584 | 1057 | *nexthdr = ext_hdr->ip6e_nxt; |
bc7a5acd | 1058 | len = (ext_hdr->ip6e_len + 2) * 4; |
31a9a584 | 1059 | } else if (*nexthdr == IPPROTO_FRAGMENT) { |
4528f34f BP |
1060 | const struct ovs_16aligned_ip6_frag *frag_hdr |
1061 | = ALIGNED_CAST(struct ovs_16aligned_ip6_frag *, data); | |
bc7a5acd | 1062 | |
31a9a584 | 1063 | *nexthdr = frag_hdr->ip6f_nxt; |
bc7a5acd | 1064 | len = sizeof *frag_hdr; |
31a9a584 | 1065 | } else if (*nexthdr == IPPROTO_ROUTING) { |
bc7a5acd AA |
1066 | const struct ip6_rthdr *rh = (struct ip6_rthdr *)data; |
1067 | ||
1068 | if (rh->ip6r_segleft > 0) { | |
1069 | return true; | |
1070 | } | |
1071 | ||
31a9a584 | 1072 | *nexthdr = rh->ip6r_nxt; |
bc7a5acd AA |
1073 | len = (rh->ip6r_len + 1) * 8; |
1074 | } else { | |
1075 | const struct ip6_ext *ext_hdr = (struct ip6_ext *)data; | |
1076 | ||
31a9a584 | 1077 | *nexthdr = ext_hdr->ip6e_nxt; |
bc7a5acd AA |
1078 | len = (ext_hdr->ip6e_len + 1) * 8; |
1079 | } | |
1080 | ||
1081 | if (remaining < len) { | |
1082 | return false; | |
1083 | } | |
1084 | remaining -= len; | |
1085 | data += len; | |
1086 | } | |
1087 | ||
1088 | return false; | |
1089 | } | |
1090 | ||
1091 | static void | |
cf62fa4c | 1092 | packet_update_csum128(struct dp_packet *packet, uint8_t proto, |
932c96b7 JR |
1093 | ovs_16aligned_be32 addr[4], |
1094 | const struct in6_addr *new_addr) | |
bc7a5acd | 1095 | { |
cf62fa4c | 1096 | size_t l4_size = dp_packet_l4_size(packet); |
5a51b2cd JR |
1097 | |
1098 | if (proto == IPPROTO_TCP && l4_size >= TCP_HEADER_LEN) { | |
cf62fa4c | 1099 | struct tcp_header *th = dp_packet_l4(packet); |
bc7a5acd AA |
1100 | |
1101 | th->tcp_csum = recalc_csum128(th->tcp_csum, addr, new_addr); | |
5a51b2cd | 1102 | } else if (proto == IPPROTO_UDP && l4_size >= UDP_HEADER_LEN) { |
cf62fa4c | 1103 | struct udp_header *uh = dp_packet_l4(packet); |
bc7a5acd AA |
1104 | |
1105 | if (uh->udp_csum) { | |
1106 | uh->udp_csum = recalc_csum128(uh->udp_csum, addr, new_addr); | |
1107 | if (!uh->udp_csum) { | |
1108 | uh->udp_csum = htons(0xffff); | |
1109 | } | |
1110 | } | |
5abf65d0 JG |
1111 | } else if (proto == IPPROTO_ICMPV6 && |
1112 | l4_size >= sizeof(struct icmp6_header)) { | |
cf62fa4c | 1113 | struct icmp6_header *icmp = dp_packet_l4(packet); |
00894212 JG |
1114 | |
1115 | icmp->icmp6_cksum = recalc_csum128(icmp->icmp6_cksum, addr, new_addr); | |
bc7a5acd AA |
1116 | } |
1117 | } | |
1118 | ||
0e29d884 | 1119 | void |
cf62fa4c | 1120 | packet_set_ipv6_addr(struct dp_packet *packet, uint8_t proto, |
932c96b7 JR |
1121 | ovs_16aligned_be32 addr[4], |
1122 | const struct in6_addr *new_addr, | |
bc7a5acd AA |
1123 | bool recalculate_csum) |
1124 | { | |
1125 | if (recalculate_csum) { | |
4528f34f | 1126 | packet_update_csum128(packet, proto, addr, new_addr); |
bc7a5acd | 1127 | } |
4068403a | 1128 | memcpy(addr, new_addr, sizeof(ovs_be32[4])); |
594570ea | 1129 | pkt_metadata_init_conn(&packet->md); |
bc7a5acd AA |
1130 | } |
1131 | ||
1132 | static void | |
4528f34f | 1133 | packet_set_ipv6_flow_label(ovs_16aligned_be32 *flow_label, ovs_be32 flow_key) |
bc7a5acd | 1134 | { |
4528f34f BP |
1135 | ovs_be32 old_label = get_16aligned_be32(flow_label); |
1136 | ovs_be32 new_label = (old_label & htonl(~IPV6_LABEL_MASK)) | flow_key; | |
1137 | put_16aligned_be32(flow_label, new_label); | |
bc7a5acd AA |
1138 | } |
1139 | ||
1140 | static void | |
4528f34f | 1141 | packet_set_ipv6_tc(ovs_16aligned_be32 *flow_label, uint8_t tc) |
bc7a5acd | 1142 | { |
4528f34f BP |
1143 | ovs_be32 old_label = get_16aligned_be32(flow_label); |
1144 | ovs_be32 new_label = (old_label & htonl(0xF00FFFFF)) | htonl(tc << 20); | |
1145 | put_16aligned_be32(flow_label, new_label); | |
bc7a5acd AA |
1146 | } |
1147 | ||
c97664b3 EJ |
1148 | /* Modifies the IPv4 header fields of 'packet' to be consistent with 'src', |
1149 | * 'dst', 'tos', and 'ttl'. Updates 'packet''s L4 checksums as appropriate. | |
1150 | * 'packet' must contain a valid IPv4 packet with correctly populated l[347] | |
1151 | * markers. */ | |
1152 | void | |
cf62fa4c | 1153 | packet_set_ipv4(struct dp_packet *packet, ovs_be32 src, ovs_be32 dst, |
c97664b3 EJ |
1154 | uint8_t tos, uint8_t ttl) |
1155 | { | |
cf62fa4c | 1156 | struct ip_header *nh = dp_packet_l3(packet); |
c97664b3 | 1157 | |
7c457c33 | 1158 | if (get_16aligned_be32(&nh->ip_src) != src) { |
c97664b3 EJ |
1159 | packet_set_ipv4_addr(packet, &nh->ip_src, src); |
1160 | } | |
1161 | ||
7c457c33 | 1162 | if (get_16aligned_be32(&nh->ip_dst) != dst) { |
c97664b3 EJ |
1163 | packet_set_ipv4_addr(packet, &nh->ip_dst, dst); |
1164 | } | |
1165 | ||
1166 | if (nh->ip_tos != tos) { | |
1167 | uint8_t *field = &nh->ip_tos; | |
1168 | ||
1169 | nh->ip_csum = recalc_csum16(nh->ip_csum, htons((uint16_t) *field), | |
1170 | htons((uint16_t) tos)); | |
1171 | *field = tos; | |
1172 | } | |
1173 | ||
1174 | if (nh->ip_ttl != ttl) { | |
1175 | uint8_t *field = &nh->ip_ttl; | |
1176 | ||
1177 | nh->ip_csum = recalc_csum16(nh->ip_csum, htons(*field << 8), | |
1178 | htons(ttl << 8)); | |
1179 | *field = ttl; | |
1180 | } | |
1181 | } | |
1182 | ||
bc7a5acd AA |
1183 | /* Modifies the IPv6 header fields of 'packet' to be consistent with 'src', |
1184 | * 'dst', 'traffic class', and 'next hop'. Updates 'packet''s L4 checksums as | |
1185 | * appropriate. 'packet' must contain a valid IPv6 packet with correctly | |
437d0d22 | 1186 | * populated l[34] offsets. */ |
bc7a5acd | 1187 | void |
932c96b7 JR |
1188 | packet_set_ipv6(struct dp_packet *packet, const struct in6_addr *src, |
1189 | const struct in6_addr *dst, uint8_t key_tc, ovs_be32 key_fl, | |
bc7a5acd AA |
1190 | uint8_t key_hl) |
1191 | { | |
cf62fa4c | 1192 | struct ovs_16aligned_ip6_hdr *nh = dp_packet_l3(packet); |
31a9a584 SH |
1193 | uint8_t proto = 0; |
1194 | bool rh_present; | |
1195 | ||
1196 | rh_present = packet_rh_present(packet, &proto); | |
bc7a5acd AA |
1197 | |
1198 | if (memcmp(&nh->ip6_src, src, sizeof(ovs_be32[4]))) { | |
4528f34f | 1199 | packet_set_ipv6_addr(packet, proto, nh->ip6_src.be32, src, true); |
bc7a5acd AA |
1200 | } |
1201 | ||
1202 | if (memcmp(&nh->ip6_dst, dst, sizeof(ovs_be32[4]))) { | |
4528f34f | 1203 | packet_set_ipv6_addr(packet, proto, nh->ip6_dst.be32, dst, |
31a9a584 | 1204 | !rh_present); |
bc7a5acd AA |
1205 | } |
1206 | ||
1207 | packet_set_ipv6_tc(&nh->ip6_flow, key_tc); | |
bc7a5acd | 1208 | packet_set_ipv6_flow_label(&nh->ip6_flow, key_fl); |
bc7a5acd AA |
1209 | nh->ip6_hlim = key_hl; |
1210 | } | |
1211 | ||
c97664b3 EJ |
1212 | static void |
1213 | packet_set_port(ovs_be16 *port, ovs_be16 new_port, ovs_be16 *csum) | |
1214 | { | |
1215 | if (*port != new_port) { | |
1216 | *csum = recalc_csum16(*csum, *port, new_port); | |
1217 | *port = new_port; | |
1218 | } | |
1219 | } | |
1220 | ||
1221 | /* Sets the TCP source and destination port ('src' and 'dst' respectively) of | |
1222 | * the TCP header contained in 'packet'. 'packet' must be a valid TCP packet | |
437d0d22 | 1223 | * with its l4 offset properly populated. */ |
c97664b3 | 1224 | void |
cf62fa4c | 1225 | packet_set_tcp_port(struct dp_packet *packet, ovs_be16 src, ovs_be16 dst) |
c97664b3 | 1226 | { |
cf62fa4c | 1227 | struct tcp_header *th = dp_packet_l4(packet); |
c97664b3 EJ |
1228 | |
1229 | packet_set_port(&th->tcp_src, src, &th->tcp_csum); | |
1230 | packet_set_port(&th->tcp_dst, dst, &th->tcp_csum); | |
594570ea | 1231 | pkt_metadata_init_conn(&packet->md); |
c97664b3 EJ |
1232 | } |
1233 | ||
1234 | /* Sets the UDP source and destination port ('src' and 'dst' respectively) of | |
1235 | * the UDP header contained in 'packet'. 'packet' must be a valid UDP packet | |
437d0d22 | 1236 | * with its l4 offset properly populated. */ |
c97664b3 | 1237 | void |
cf62fa4c | 1238 | packet_set_udp_port(struct dp_packet *packet, ovs_be16 src, ovs_be16 dst) |
c97664b3 | 1239 | { |
cf62fa4c | 1240 | struct udp_header *uh = dp_packet_l4(packet); |
c97664b3 EJ |
1241 | |
1242 | if (uh->udp_csum) { | |
1243 | packet_set_port(&uh->udp_src, src, &uh->udp_csum); | |
1244 | packet_set_port(&uh->udp_dst, dst, &uh->udp_csum); | |
1245 | ||
1246 | if (!uh->udp_csum) { | |
1247 | uh->udp_csum = htons(0xffff); | |
1248 | } | |
1249 | } else { | |
1250 | uh->udp_src = src; | |
1251 | uh->udp_dst = dst; | |
1252 | } | |
594570ea | 1253 | pkt_metadata_init_conn(&packet->md); |
c97664b3 | 1254 | } |
12113c39 | 1255 | |
c6bcb685 JS |
1256 | /* Sets the SCTP source and destination port ('src' and 'dst' respectively) of |
1257 | * the SCTP header contained in 'packet'. 'packet' must be a valid SCTP packet | |
437d0d22 | 1258 | * with its l4 offset properly populated. */ |
c6bcb685 | 1259 | void |
cf62fa4c | 1260 | packet_set_sctp_port(struct dp_packet *packet, ovs_be16 src, ovs_be16 dst) |
c6bcb685 | 1261 | { |
cf62fa4c | 1262 | struct sctp_header *sh = dp_packet_l4(packet); |
c6bcb685 | 1263 | ovs_be32 old_csum, old_correct_csum, new_csum; |
cf62fa4c | 1264 | uint16_t tp_len = dp_packet_l4_size(packet); |
c6bcb685 | 1265 | |
5fa008d4 BP |
1266 | old_csum = get_16aligned_be32(&sh->sctp_csum); |
1267 | put_16aligned_be32(&sh->sctp_csum, 0); | |
437d0d22 | 1268 | old_correct_csum = crc32c((void *)sh, tp_len); |
c6bcb685 JS |
1269 | |
1270 | sh->sctp_src = src; | |
1271 | sh->sctp_dst = dst; | |
1272 | ||
437d0d22 | 1273 | new_csum = crc32c((void *)sh, tp_len); |
5fa008d4 | 1274 | put_16aligned_be32(&sh->sctp_csum, old_csum ^ old_correct_csum ^ new_csum); |
594570ea | 1275 | pkt_metadata_init_conn(&packet->md); |
c6bcb685 JS |
1276 | } |
1277 | ||
b8786b18 JP |
1278 | /* Sets the ICMP type and code of the ICMP header contained in 'packet'. |
1279 | * 'packet' must be a valid ICMP packet with its l4 offset properly | |
1280 | * populated. */ | |
1281 | void | |
1282 | packet_set_icmp(struct dp_packet *packet, uint8_t type, uint8_t code) | |
1283 | { | |
1284 | struct icmp_header *ih = dp_packet_l4(packet); | |
1285 | ovs_be16 orig_tc = htons(ih->icmp_type << 8 | ih->icmp_code); | |
1286 | ovs_be16 new_tc = htons(type << 8 | code); | |
1287 | ||
1288 | if (orig_tc != new_tc) { | |
1289 | ih->icmp_type = type; | |
1290 | ih->icmp_code = code; | |
1291 | ||
1292 | ih->icmp_csum = recalc_csum16(ih->icmp_csum, orig_tc, new_tc); | |
1293 | } | |
594570ea | 1294 | pkt_metadata_init_conn(&packet->md); |
b8786b18 JP |
1295 | } |
1296 | ||
1db44453 DC |
1297 | /* Sets the IGMP type to IGMP_HOST_MEMBERSHIP_QUERY and populates the |
1298 | * v3 query header fields in 'packet'. 'packet' must be a valid IGMPv3 | |
1299 | * query packet with its l4 offset properly populated. | |
1300 | */ | |
1301 | void | |
1302 | packet_set_igmp3_query(struct dp_packet *packet, uint8_t max_resp, | |
1303 | ovs_be32 group, bool srs, uint8_t qrv, uint8_t qqic) | |
1304 | { | |
1305 | struct igmpv3_query_header *igh = dp_packet_l4(packet); | |
1306 | ovs_be16 orig_type_max_resp = | |
1307 | htons(igh->type << 8 | igh->max_resp); | |
1308 | ovs_be16 new_type_max_resp = | |
1309 | htons(IGMP_HOST_MEMBERSHIP_QUERY << 8 | max_resp); | |
1310 | ||
1311 | if (orig_type_max_resp != new_type_max_resp) { | |
1312 | igh->type = IGMP_HOST_MEMBERSHIP_QUERY; | |
1313 | igh->max_resp = max_resp; | |
1314 | igh->csum = recalc_csum16(igh->csum, orig_type_max_resp, | |
1315 | new_type_max_resp); | |
1316 | } | |
1317 | ||
1318 | ovs_be32 old_group = get_16aligned_be32(&igh->group); | |
1319 | ||
1320 | if (old_group != group) { | |
1321 | put_16aligned_be32(&igh->group, group); | |
1322 | igh->csum = recalc_csum32(igh->csum, old_group, group); | |
1323 | } | |
1324 | ||
1325 | /* See RFC 3376 4.1.6. */ | |
1326 | if (qrv > 7) { | |
1327 | qrv = 0; | |
1328 | } | |
1329 | ||
1330 | ovs_be16 orig_srs_qrv_qqic = htons(igh->srs_qrv << 8 | igh->qqic); | |
1331 | ovs_be16 new_srs_qrv_qqic = htons(srs << 11 | qrv << 8 | qqic); | |
1332 | ||
1333 | if (orig_srs_qrv_qqic != new_srs_qrv_qqic) { | |
1334 | igh->srs_qrv = (srs << 3 | qrv); | |
1335 | igh->qqic = qqic; | |
1336 | igh->csum = recalc_csum16(igh->csum, orig_srs_qrv_qqic, | |
1337 | new_srs_qrv_qqic); | |
1338 | } | |
1339 | } | |
1340 | ||
9b2b8497 VDA |
1341 | void |
1342 | packet_set_nd_ext(struct dp_packet *packet, const ovs_16aligned_be32 rso_flags, | |
1343 | const uint8_t opt_type) | |
1344 | { | |
1345 | struct ovs_nd_msg *ns; | |
1346 | struct ovs_nd_lla_opt *opt; | |
1347 | int bytes_remain = dp_packet_l4_size(packet); | |
1348 | struct ovs_16aligned_ip6_hdr * nh = dp_packet_l3(packet); | |
1349 | uint32_t pseudo_hdr_csum = 0; | |
1350 | ||
1351 | if (OVS_UNLIKELY(bytes_remain < sizeof(*ns))) { | |
1352 | return; | |
1353 | } | |
1354 | ||
1355 | if (nh) { | |
1356 | pseudo_hdr_csum = packet_csum_pseudoheader6(nh); | |
1357 | } | |
1358 | ||
1359 | ns = dp_packet_l4(packet); | |
1360 | opt = &ns->options[0]; | |
1361 | ||
1362 | /* set RSO flags and option type */ | |
1363 | ns->rso_flags = rso_flags; | |
1364 | opt->type = opt_type; | |
1365 | ||
1366 | /* recalculate checksum */ | |
1367 | ovs_be16 *csum_value = &(ns->icmph.icmp6_cksum); | |
1368 | *csum_value = 0; | |
1369 | *csum_value = csum_finish(csum_continue(pseudo_hdr_csum, | |
1370 | &(ns->icmph), bytes_remain)); | |
1371 | ||
1372 | } | |
1373 | ||
e60e935b | 1374 | void |
932c96b7 | 1375 | packet_set_nd(struct dp_packet *packet, const struct in6_addr *target, |
c4bee4cb PS |
1376 | const struct eth_addr sll, const struct eth_addr tll) |
1377 | { | |
e60e935b | 1378 | struct ovs_nd_msg *ns; |
86d46f3c | 1379 | struct ovs_nd_lla_opt *opt; |
cf62fa4c | 1380 | int bytes_remain = dp_packet_l4_size(packet); |
e60e935b SRCSA |
1381 | |
1382 | if (OVS_UNLIKELY(bytes_remain < sizeof(*ns))) { | |
1383 | return; | |
1384 | } | |
1385 | ||
cf62fa4c | 1386 | ns = dp_packet_l4(packet); |
86d46f3c | 1387 | opt = &ns->options[0]; |
e60e935b SRCSA |
1388 | bytes_remain -= sizeof(*ns); |
1389 | ||
1390 | if (memcmp(&ns->target, target, sizeof(ovs_be32[4]))) { | |
932c96b7 JR |
1391 | packet_set_ipv6_addr(packet, IPPROTO_ICMPV6, ns->target.be32, target, |
1392 | true); | |
e60e935b SRCSA |
1393 | } |
1394 | ||
86d46f3c ZKL |
1395 | while (bytes_remain >= ND_LLA_OPT_LEN && opt->len != 0) { |
1396 | if (opt->type == ND_OPT_SOURCE_LINKADDR && opt->len == 1) { | |
1397 | if (!eth_addr_equals(opt->mac, sll)) { | |
e60e935b SRCSA |
1398 | ovs_be16 *csum = &(ns->icmph.icmp6_cksum); |
1399 | ||
86d46f3c ZKL |
1400 | *csum = recalc_csum48(*csum, opt->mac, sll); |
1401 | opt->mac = sll; | |
e60e935b SRCSA |
1402 | } |
1403 | ||
1404 | /* A packet can only contain one SLL or TLL option */ | |
1405 | break; | |
86d46f3c ZKL |
1406 | } else if (opt->type == ND_OPT_TARGET_LINKADDR && opt->len == 1) { |
1407 | if (!eth_addr_equals(opt->mac, tll)) { | |
e60e935b SRCSA |
1408 | ovs_be16 *csum = &(ns->icmph.icmp6_cksum); |
1409 | ||
86d46f3c ZKL |
1410 | *csum = recalc_csum48(*csum, opt->mac, tll); |
1411 | opt->mac = tll; | |
e60e935b SRCSA |
1412 | } |
1413 | ||
1414 | /* A packet can only contain one SLL or TLL option */ | |
1415 | break; | |
1416 | } | |
1417 | ||
86d46f3c ZKL |
1418 | opt += opt->len; |
1419 | bytes_remain -= opt->len * ND_LLA_OPT_LEN; | |
e60e935b SRCSA |
1420 | } |
1421 | } | |
1422 | ||
61bf6666 JR |
1423 | const char * |
1424 | packet_tcp_flag_to_string(uint32_t flag) | |
1425 | { | |
1426 | switch (flag) { | |
1427 | case TCP_FIN: | |
1428 | return "fin"; | |
1429 | case TCP_SYN: | |
1430 | return "syn"; | |
1431 | case TCP_RST: | |
1432 | return "rst"; | |
1433 | case TCP_PSH: | |
1434 | return "psh"; | |
1435 | case TCP_ACK: | |
1436 | return "ack"; | |
1437 | case TCP_URG: | |
1438 | return "urg"; | |
1439 | case TCP_ECE: | |
1440 | return "ece"; | |
1441 | case TCP_CWR: | |
1442 | return "cwr"; | |
1443 | case TCP_NS: | |
1444 | return "ns"; | |
1445 | case 0x200: | |
1446 | return "[200]"; | |
1447 | case 0x400: | |
1448 | return "[400]"; | |
1449 | case 0x800: | |
1450 | return "[800]"; | |
1451 | default: | |
1452 | return NULL; | |
1453 | } | |
1454 | } | |
1455 | ||
7393104d | 1456 | /* Appends a string representation of the TCP flags value 'tcp_flags' |
f41b5b3b | 1457 | * (e.g. from struct flow.tcp_flags or obtained via TCP_FLAGS) to 's', in the |
7393104d BP |
1458 | * format used by tcpdump. */ |
1459 | void | |
a66733a8 | 1460 | packet_format_tcp_flags(struct ds *s, uint16_t tcp_flags) |
7393104d BP |
1461 | { |
1462 | if (!tcp_flags) { | |
1463 | ds_put_cstr(s, "none"); | |
1464 | return; | |
1465 | } | |
1466 | ||
1467 | if (tcp_flags & TCP_SYN) { | |
1468 | ds_put_char(s, 'S'); | |
1469 | } | |
1470 | if (tcp_flags & TCP_FIN) { | |
1471 | ds_put_char(s, 'F'); | |
1472 | } | |
1473 | if (tcp_flags & TCP_PSH) { | |
1474 | ds_put_char(s, 'P'); | |
1475 | } | |
1476 | if (tcp_flags & TCP_RST) { | |
1477 | ds_put_char(s, 'R'); | |
1478 | } | |
1479 | if (tcp_flags & TCP_URG) { | |
1480 | ds_put_char(s, 'U'); | |
1481 | } | |
1482 | if (tcp_flags & TCP_ACK) { | |
1483 | ds_put_char(s, '.'); | |
1484 | } | |
a66733a8 JR |
1485 | if (tcp_flags & TCP_ECE) { |
1486 | ds_put_cstr(s, "E"); | |
7393104d | 1487 | } |
a66733a8 JR |
1488 | if (tcp_flags & TCP_CWR) { |
1489 | ds_put_cstr(s, "C"); | |
1490 | } | |
1491 | if (tcp_flags & TCP_NS) { | |
1492 | ds_put_cstr(s, "N"); | |
1493 | } | |
1494 | if (tcp_flags & 0x200) { | |
1495 | ds_put_cstr(s, "[200]"); | |
1496 | } | |
1497 | if (tcp_flags & 0x400) { | |
1498 | ds_put_cstr(s, "[400]"); | |
1499 | } | |
1500 | if (tcp_flags & 0x800) { | |
1501 | ds_put_cstr(s, "[800]"); | |
7393104d BP |
1502 | } |
1503 | } | |
a36de779 PS |
1504 | |
1505 | #define ARP_PACKET_SIZE (2 + ETH_HEADER_LEN + VLAN_HEADER_LEN + \ | |
1506 | ARP_ETH_HEADER_LEN) | |
1507 | ||
eb0b295e BP |
1508 | /* Clears 'b' and replaces its contents by an ARP frame with the specified |
1509 | * 'arp_op', 'arp_sha', 'arp_tha', 'arp_spa', and 'arp_tpa'. The outer | |
1510 | * Ethernet frame is initialized with Ethernet source 'arp_sha' and destination | |
1511 | * 'arp_tha', except that destination ff:ff:ff:ff:ff:ff is used instead if | |
6335d074 | 1512 | * 'broadcast' is true. Points the L3 header to the ARP header. */ |
a36de779 | 1513 | void |
eb0b295e | 1514 | compose_arp(struct dp_packet *b, uint16_t arp_op, |
74ff3298 JR |
1515 | const struct eth_addr arp_sha, const struct eth_addr arp_tha, |
1516 | bool broadcast, ovs_be32 arp_spa, ovs_be32 arp_tpa) | |
a36de779 | 1517 | { |
6335d074 BP |
1518 | compose_arp__(b); |
1519 | ||
2482b0b0 | 1520 | struct eth_header *eth = dp_packet_eth(b); |
6335d074 BP |
1521 | eth->eth_dst = broadcast ? eth_addr_broadcast : arp_tha; |
1522 | eth->eth_src = arp_sha; | |
1523 | ||
1524 | struct arp_eth_header *arp = dp_packet_l3(b); | |
1525 | arp->ar_op = htons(arp_op); | |
1526 | arp->ar_sha = arp_sha; | |
1527 | arp->ar_tha = arp_tha; | |
1528 | put_16aligned_be32(&arp->ar_spa, arp_spa); | |
1529 | put_16aligned_be32(&arp->ar_tpa, arp_tpa); | |
1530 | } | |
a36de779 | 1531 | |
6335d074 BP |
1532 | /* Clears 'b' and replaces its contents by an ARP frame. Sets the fields in |
1533 | * the Ethernet and ARP headers that are fixed for ARP frames to those fixed | |
1534 | * values, and zeroes the other fields. Points the L3 header to the ARP | |
1535 | * header. */ | |
1536 | void | |
1537 | compose_arp__(struct dp_packet *b) | |
1538 | { | |
cf62fa4c PS |
1539 | dp_packet_clear(b); |
1540 | dp_packet_prealloc_tailroom(b, ARP_PACKET_SIZE); | |
1541 | dp_packet_reserve(b, 2 + VLAN_HEADER_LEN); | |
a36de779 | 1542 | |
6335d074 | 1543 | struct eth_header *eth = dp_packet_put_zeros(b, sizeof *eth); |
a36de779 PS |
1544 | eth->eth_type = htons(ETH_TYPE_ARP); |
1545 | ||
6335d074 | 1546 | struct arp_eth_header *arp = dp_packet_put_zeros(b, sizeof *arp); |
a36de779 PS |
1547 | arp->ar_hrd = htons(ARP_HRD_ETHERNET); |
1548 | arp->ar_pro = htons(ARP_PRO_IP); | |
1549 | arp->ar_hln = sizeof arp->ar_sha; | |
1550 | arp->ar_pln = sizeof arp->ar_spa; | |
a36de779 | 1551 | |
82eb5b0a | 1552 | dp_packet_reset_offsets(b); |
cf62fa4c | 1553 | dp_packet_set_l3(b, arp); |
2482b0b0 JS |
1554 | |
1555 | b->packet_type = htonl(PT_ETH); | |
a36de779 | 1556 | } |
0292a0c9 | 1557 | |
16187903 | 1558 | /* This function expects packet with ethernet header with correct |
c4bee4cb | 1559 | * l3 pointer set. */ |
cec89046 | 1560 | void * |
16187903 JP |
1561 | compose_ipv6(struct dp_packet *packet, uint8_t proto, |
1562 | const struct in6_addr *src, const struct in6_addr *dst, | |
1563 | uint8_t key_tc, ovs_be32 key_fl, uint8_t key_hl, int size) | |
c4bee4cb PS |
1564 | { |
1565 | struct ip6_hdr *nh; | |
1566 | void *data; | |
1567 | ||
1568 | nh = dp_packet_l3(packet); | |
1569 | nh->ip6_vfc = 0x60; | |
1570 | nh->ip6_nxt = proto; | |
1571 | nh->ip6_plen = htons(size); | |
1572 | data = dp_packet_put_zeros(packet, size); | |
1573 | dp_packet_set_l4(packet, data); | |
932c96b7 | 1574 | packet_set_ipv6(packet, src, dst, key_tc, key_fl, key_hl); |
c4bee4cb PS |
1575 | return data; |
1576 | } | |
1577 | ||
16187903 | 1578 | /* Compose an IPv6 Neighbor Discovery Neighbor Solicitation message. */ |
c2b878e0 | 1579 | void |
16187903 JP |
1580 | compose_nd_ns(struct dp_packet *b, const struct eth_addr eth_src, |
1581 | const struct in6_addr *ipv6_src, const struct in6_addr *ipv6_dst) | |
c2b878e0 TLSC |
1582 | { |
1583 | struct in6_addr sn_addr; | |
1584 | struct eth_addr eth_dst; | |
1585 | struct ovs_nd_msg *ns; | |
86d46f3c | 1586 | struct ovs_nd_lla_opt *lla_opt; |
c4bee4cb | 1587 | uint32_t icmp_csum; |
c2b878e0 TLSC |
1588 | |
1589 | in6_addr_solicited_node(&sn_addr, ipv6_dst); | |
1590 | ipv6_multicast_to_ethernet(ð_dst, &sn_addr); | |
1591 | ||
c4bee4cb | 1592 | eth_compose(b, eth_dst, eth_src, ETH_TYPE_IPV6, IPV6_HEADER_LEN); |
16187903 | 1593 | ns = compose_ipv6(b, IPPROTO_ICMPV6, ipv6_src, &sn_addr, |
86d46f3c | 1594 | 0, 0, 255, ND_MSG_LEN + ND_LLA_OPT_LEN); |
c2b878e0 TLSC |
1595 | |
1596 | ns->icmph.icmp6_type = ND_NEIGHBOR_SOLICIT; | |
1597 | ns->icmph.icmp6_code = 0; | |
29d5e9a7 | 1598 | put_16aligned_be32(&ns->rso_flags, htonl(0)); |
c2b878e0 | 1599 | |
86d46f3c ZKL |
1600 | lla_opt = &ns->options[0]; |
1601 | lla_opt->type = ND_OPT_SOURCE_LINKADDR; | |
1602 | lla_opt->len = 1; | |
c4bee4cb | 1603 | |
932c96b7 | 1604 | packet_set_nd(b, ipv6_dst, eth_src, eth_addr_zero); |
16187903 | 1605 | |
c4bee4cb PS |
1606 | ns->icmph.icmp6_cksum = 0; |
1607 | icmp_csum = packet_csum_pseudoheader6(dp_packet_l3(b)); | |
86d46f3c ZKL |
1608 | ns->icmph.icmp6_cksum = csum_finish( |
1609 | csum_continue(icmp_csum, ns, ND_MSG_LEN + ND_LLA_OPT_LEN)); | |
c2b878e0 TLSC |
1610 | } |
1611 | ||
16187903 | 1612 | /* Compose an IPv6 Neighbor Discovery Neighbor Advertisement message. */ |
e75451fe | 1613 | void |
16187903 JP |
1614 | compose_nd_na(struct dp_packet *b, |
1615 | const struct eth_addr eth_src, const struct eth_addr eth_dst, | |
1616 | const struct in6_addr *ipv6_src, const struct in6_addr *ipv6_dst, | |
1617 | ovs_be32 rso_flags) | |
e75451fe ZKL |
1618 | { |
1619 | struct ovs_nd_msg *na; | |
86d46f3c | 1620 | struct ovs_nd_lla_opt *lla_opt; |
e75451fe ZKL |
1621 | uint32_t icmp_csum; |
1622 | ||
1623 | eth_compose(b, eth_dst, eth_src, ETH_TYPE_IPV6, IPV6_HEADER_LEN); | |
16187903 | 1624 | na = compose_ipv6(b, IPPROTO_ICMPV6, ipv6_src, ipv6_dst, |
86d46f3c | 1625 | 0, 0, 255, ND_MSG_LEN + ND_LLA_OPT_LEN); |
e75451fe ZKL |
1626 | |
1627 | na->icmph.icmp6_type = ND_NEIGHBOR_ADVERT; | |
1628 | na->icmph.icmp6_code = 0; | |
29d5e9a7 | 1629 | put_16aligned_be32(&na->rso_flags, rso_flags); |
e75451fe | 1630 | |
86d46f3c ZKL |
1631 | lla_opt = &na->options[0]; |
1632 | lla_opt->type = ND_OPT_TARGET_LINKADDR; | |
1633 | lla_opt->len = 1; | |
e75451fe | 1634 | |
932c96b7 | 1635 | packet_set_nd(b, ipv6_src, eth_addr_zero, eth_src); |
16187903 | 1636 | |
e75451fe ZKL |
1637 | na->icmph.icmp6_cksum = 0; |
1638 | icmp_csum = packet_csum_pseudoheader6(dp_packet_l3(b)); | |
86d46f3c ZKL |
1639 | na->icmph.icmp6_cksum = csum_finish(csum_continue( |
1640 | icmp_csum, na, ND_MSG_LEN + ND_LLA_OPT_LEN)); | |
e75451fe ZKL |
1641 | } |
1642 | ||
b24ab67c ZKL |
1643 | /* Compose an IPv6 Neighbor Discovery Router Advertisement message with |
1644 | * Source Link-layer Address Option and MTU Option. | |
1645 | * Caller can call packet_put_ra_prefix_opt to append Prefix Information | |
1646 | * Options to composed messags in 'b'. */ | |
1647 | void | |
1648 | compose_nd_ra(struct dp_packet *b, | |
1649 | const struct eth_addr eth_src, const struct eth_addr eth_dst, | |
1650 | const struct in6_addr *ipv6_src, const struct in6_addr *ipv6_dst, | |
1651 | uint8_t cur_hop_limit, uint8_t mo_flags, | |
1652 | ovs_be16 router_lt, ovs_be32 reachable_time, | |
4446661a | 1653 | ovs_be32 retrans_timer, uint32_t mtu) |
b24ab67c ZKL |
1654 | { |
1655 | /* Don't compose Router Advertisement packet with MTU Option if mtu | |
1656 | * value is 0. */ | |
1657 | bool with_mtu = mtu != 0; | |
1658 | size_t mtu_opt_len = with_mtu ? ND_MTU_OPT_LEN : 0; | |
1659 | ||
1660 | eth_compose(b, eth_dst, eth_src, ETH_TYPE_IPV6, IPV6_HEADER_LEN); | |
1661 | ||
1662 | struct ovs_ra_msg *ra = compose_ipv6( | |
1663 | b, IPPROTO_ICMPV6, ipv6_src, ipv6_dst, 0, 0, 255, | |
86d46f3c | 1664 | RA_MSG_LEN + ND_LLA_OPT_LEN + mtu_opt_len); |
b24ab67c ZKL |
1665 | ra->icmph.icmp6_type = ND_ROUTER_ADVERT; |
1666 | ra->icmph.icmp6_code = 0; | |
1667 | ra->cur_hop_limit = cur_hop_limit; | |
1668 | ra->mo_flags = mo_flags; | |
1669 | ra->router_lifetime = router_lt; | |
1670 | ra->reachable_time = reachable_time; | |
1671 | ra->retrans_timer = retrans_timer; | |
1672 | ||
86d46f3c ZKL |
1673 | struct ovs_nd_lla_opt *lla_opt = ra->options; |
1674 | lla_opt->type = ND_OPT_SOURCE_LINKADDR; | |
1675 | lla_opt->len = 1; | |
1676 | lla_opt->mac = eth_src; | |
b24ab67c ZKL |
1677 | |
1678 | if (with_mtu) { | |
86d46f3c | 1679 | /* ovs_nd_mtu_opt has the same size with ovs_nd_lla_opt. */ |
b24ab67c ZKL |
1680 | struct ovs_nd_mtu_opt *mtu_opt |
1681 | = (struct ovs_nd_mtu_opt *)(lla_opt + 1); | |
1682 | mtu_opt->type = ND_OPT_MTU; | |
1683 | mtu_opt->len = 1; | |
1684 | mtu_opt->reserved = 0; | |
4446661a | 1685 | put_16aligned_be32(&mtu_opt->mtu, htonl(mtu)); |
b24ab67c ZKL |
1686 | } |
1687 | ||
1688 | ra->icmph.icmp6_cksum = 0; | |
1689 | uint32_t icmp_csum = packet_csum_pseudoheader6(dp_packet_l3(b)); | |
1690 | ra->icmph.icmp6_cksum = csum_finish(csum_continue( | |
86d46f3c | 1691 | icmp_csum, ra, RA_MSG_LEN + ND_LLA_OPT_LEN + mtu_opt_len)); |
b24ab67c ZKL |
1692 | } |
1693 | ||
1694 | /* Append an IPv6 Neighbor Discovery Prefix Information option to a | |
1695 | * Router Advertisement message. */ | |
1696 | void | |
1697 | packet_put_ra_prefix_opt(struct dp_packet *b, | |
1698 | uint8_t plen, uint8_t la_flags, | |
1699 | ovs_be32 valid_lifetime, ovs_be32 preferred_lifetime, | |
1700 | const ovs_be128 prefix) | |
1701 | { | |
1702 | size_t prev_l4_size = dp_packet_l4_size(b); | |
1703 | struct ip6_hdr *nh = dp_packet_l3(b); | |
1704 | nh->ip6_plen = htons(prev_l4_size + ND_PREFIX_OPT_LEN); | |
1705 | ||
481ada4d NS |
1706 | struct ovs_nd_prefix_opt *prefix_opt = |
1707 | dp_packet_put_uninit(b, sizeof *prefix_opt); | |
b24ab67c ZKL |
1708 | prefix_opt->type = ND_OPT_PREFIX_INFORMATION; |
1709 | prefix_opt->len = 4; | |
1710 | prefix_opt->prefix_len = plen; | |
1711 | prefix_opt->la_flags = la_flags; | |
1712 | put_16aligned_be32(&prefix_opt->valid_lifetime, valid_lifetime); | |
1713 | put_16aligned_be32(&prefix_opt->preferred_lifetime, preferred_lifetime); | |
1714 | put_16aligned_be32(&prefix_opt->reserved, 0); | |
1715 | memcpy(prefix_opt->prefix.be32, prefix.be32, sizeof(ovs_be32[4])); | |
1716 | ||
4123c212 | 1717 | struct ovs_ra_msg *ra = dp_packet_l4(b); |
b24ab67c ZKL |
1718 | ra->icmph.icmp6_cksum = 0; |
1719 | uint32_t icmp_csum = packet_csum_pseudoheader6(dp_packet_l3(b)); | |
1720 | ra->icmph.icmp6_cksum = csum_finish(csum_continue( | |
1721 | icmp_csum, ra, prev_l4_size + ND_PREFIX_OPT_LEN)); | |
1722 | } | |
1723 | ||
0292a0c9 JG |
1724 | uint32_t |
1725 | packet_csum_pseudoheader(const struct ip_header *ip) | |
1726 | { | |
1727 | uint32_t partial = 0; | |
1728 | ||
1729 | partial = csum_add32(partial, get_16aligned_be32(&ip->ip_src)); | |
1730 | partial = csum_add32(partial, get_16aligned_be32(&ip->ip_dst)); | |
1731 | partial = csum_add16(partial, htons(ip->ip_proto)); | |
1732 | partial = csum_add16(partial, htons(ntohs(ip->ip_tot_len) - | |
1733 | IP_IHL(ip->ip_ihl_ver) * 4)); | |
1734 | ||
1735 | return partial; | |
1736 | } | |
07659514 | 1737 | |
370e373b TLSC |
1738 | #ifndef __CHECKER__ |
1739 | uint32_t | |
1740 | packet_csum_pseudoheader6(const struct ovs_16aligned_ip6_hdr *ip6) | |
1741 | { | |
1742 | uint32_t partial = 0; | |
1743 | ||
cfa354cb BP |
1744 | partial = csum_continue(partial, &ip6->ip6_src, sizeof ip6->ip6_src); |
1745 | partial = csum_continue(partial, &ip6->ip6_dst, sizeof ip6->ip6_dst); | |
c4bee4cb | 1746 | partial = csum_add16(partial, htons(ip6->ip6_nxt)); |
370e373b | 1747 | partial = csum_add16(partial, ip6->ip6_plen); |
370e373b TLSC |
1748 | |
1749 | return partial; | |
1750 | } | |
46445c63 EC |
1751 | |
1752 | /* Calculate the IPv6 upper layer checksum according to RFC2460. We pass the | |
1753 | ip6_nxt and ip6_plen values, so it will also work if extension headers | |
1754 | are present. */ | |
5be00cf9 | 1755 | ovs_be16 |
46445c63 EC |
1756 | packet_csum_upperlayer6(const struct ovs_16aligned_ip6_hdr *ip6, |
1757 | const void *data, uint8_t l4_protocol, | |
1758 | uint16_t l4_size) | |
1759 | { | |
1760 | uint32_t partial = 0; | |
1761 | ||
1762 | partial = csum_continue(partial, &ip6->ip6_src, sizeof ip6->ip6_src); | |
1763 | partial = csum_continue(partial, &ip6->ip6_dst, sizeof ip6->ip6_dst); | |
1764 | partial = csum_add16(partial, htons(l4_protocol)); | |
1765 | partial = csum_add16(partial, htons(l4_size)); | |
1766 | ||
1767 | partial = csum_continue(partial, data, l4_size); | |
1768 | ||
1769 | return csum_finish(partial); | |
1770 | } | |
370e373b | 1771 | #endif |
1bc3f0ed PS |
1772 | |
1773 | void | |
1774 | IP_ECN_set_ce(struct dp_packet *pkt, bool is_ipv6) | |
1775 | { | |
1776 | if (is_ipv6) { | |
1777 | ovs_16aligned_be32 *ip6 = dp_packet_l3(pkt); | |
1778 | ||
1779 | put_16aligned_be32(ip6, get_16aligned_be32(ip6) | | |
1780 | htonl(IP_ECN_CE << 20)); | |
1781 | } else { | |
1782 | struct ip_header *nh = dp_packet_l3(pkt); | |
1783 | uint8_t tos = nh->ip_tos; | |
1784 | ||
1785 | tos |= IP_ECN_CE; | |
1786 | if (nh->ip_tos != tos) { | |
1787 | nh->ip_csum = recalc_csum16(nh->ip_csum, htons(nh->ip_tos), | |
1788 | htons((uint16_t) tos)); | |
1789 | nh->ip_tos = tos; | |
1790 | } | |
1791 | } | |
1792 | } |