/*
- * Copyright (c) 2009, 2010, 2011 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <netinet/in.h>
#include <stdlib.h>
#include "byte-order.h"
+#include "csum.h"
+#include "flow.h"
#include "dynamic-string.h"
#include "ofpbuf.h"
return *dpidp != 0;
}
+/* Returns true if 'ea' is a reserved multicast address, that a bridge must
+ * never forward, false otherwise. Includes some proprietary vendor protocols
+ * that shouldn't be forwarded as well.
+ *
+ * If you change this function's behavior, please update corresponding
+ * documentation in vswitch.xml at the same time. */
+bool
+eth_addr_is_reserved(const uint8_t ea[ETH_ADDR_LEN])
+{
+ struct masked_eth_addr {
+ uint8_t ea[ETH_ADDR_LEN];
+ uint8_t mask[ETH_ADDR_LEN];
+ };
+
+ static struct masked_eth_addr mea[] = {
+ { /* STP, IEEE pause frames, and other reserved protocols. */
+ {0x01, 0x08, 0xc2, 0x00, 0x00, 0x00},
+ {0xff, 0xff, 0xff, 0xff, 0xff, 0xf0}},
+
+ { /* Cisco Inter Switch Link. */
+ {0x01, 0x00, 0x0c, 0x00, 0x00, 0x00},
+ {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
+
+ { /* Cisco protocols plus others following the same pattern:
+ *
+ * CDP, VTP, DTP, PAgP (01-00-0c-cc-cc-cc)
+ * Spanning Tree PVSTP+ (01-00-0c-cc-cc-cd)
+ * STP Uplink Fast (01-00-0c-cd-cd-cd) */
+ {0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc},
+ {0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe}}};
+
+ size_t i;
+
+ for (i = 0; i < ARRAY_SIZE(mea); i++) {
+ if (eth_addr_equal_except(ea, mea[i].ea, mea[i].mask)) {
+ return true;
+ }
+ }
+ return false;
+}
+
bool
eth_addr_from_string(const char *s, uint8_t ea[ETH_ADDR_LEN])
{
return NULL;
}
+void
+eth_format_masked(const uint8_t eth[ETH_ADDR_LEN],
+ const uint8_t mask[ETH_ADDR_LEN], struct ds *s)
+{
+ ds_put_format(s, ETH_ADDR_FMT, ETH_ADDR_ARGS(eth));
+ if (mask && !eth_mask_is_exact(mask)) {
+ ds_put_format(s, "/"ETH_ADDR_FMT, ETH_ADDR_ARGS(mask));
+ }
+}
+
+void
+eth_addr_bitand(const uint8_t src[ETH_ADDR_LEN],
+ const uint8_t mask[ETH_ADDR_LEN],
+ uint8_t dst[ETH_ADDR_LEN])
+{
+ int i;
+
+ for (i = 0; i < ETH_ADDR_LEN; i++) {
+ dst[i] = src[i] & mask[i];
+ }
+}
+
/* Given the IP netmask 'netmask', returns the number of bits of the IP address
* that it specifies, that is, the number of 1-bits in 'netmask'. 'netmask'
* must be a CIDR netmask (see ip_is_cidr()). */
return payload;
}
+
+static void
+packet_set_ipv4_addr(struct ofpbuf *packet, ovs_be32 *addr, ovs_be32 new_addr)
+{
+ struct ip_header *nh = packet->l3;
+
+ if (nh->ip_proto == IPPROTO_TCP && packet->l7) {
+ struct tcp_header *th = packet->l4;
+
+ th->tcp_csum = recalc_csum32(th->tcp_csum, *addr, new_addr);
+ } else if (nh->ip_proto == IPPROTO_UDP && packet->l7) {
+ struct udp_header *uh = packet->l4;
+
+ if (uh->udp_csum) {
+ uh->udp_csum = recalc_csum32(uh->udp_csum, *addr, new_addr);
+ if (!uh->udp_csum) {
+ uh->udp_csum = htons(0xffff);
+ }
+ }
+ }
+ nh->ip_csum = recalc_csum32(nh->ip_csum, *addr, new_addr);
+ *addr = new_addr;
+}
+
+/* Modifies the IPv4 header fields of 'packet' to be consistent with 'src',
+ * 'dst', 'tos', and 'ttl'. Updates 'packet''s L4 checksums as appropriate.
+ * 'packet' must contain a valid IPv4 packet with correctly populated l[347]
+ * markers. */
+void
+packet_set_ipv4(struct ofpbuf *packet, ovs_be32 src, ovs_be32 dst,
+ uint8_t tos, uint8_t ttl)
+{
+ struct ip_header *nh = packet->l3;
+
+ if (nh->ip_src != src) {
+ packet_set_ipv4_addr(packet, &nh->ip_src, src);
+ }
+
+ if (nh->ip_dst != dst) {
+ packet_set_ipv4_addr(packet, &nh->ip_dst, dst);
+ }
+
+ if (nh->ip_tos != tos) {
+ uint8_t *field = &nh->ip_tos;
+
+ nh->ip_csum = recalc_csum16(nh->ip_csum, htons((uint16_t) *field),
+ htons((uint16_t) tos));
+ *field = tos;
+ }
+
+ if (nh->ip_ttl != ttl) {
+ uint8_t *field = &nh->ip_ttl;
+
+ nh->ip_csum = recalc_csum16(nh->ip_csum, htons(*field << 8),
+ htons(ttl << 8));
+ *field = ttl;
+ }
+}
+
+static void
+packet_set_port(ovs_be16 *port, ovs_be16 new_port, ovs_be16 *csum)
+{
+ if (*port != new_port) {
+ *csum = recalc_csum16(*csum, *port, new_port);
+ *port = new_port;
+ }
+}
+
+/* Sets the TCP source and destination port ('src' and 'dst' respectively) of
+ * the TCP header contained in 'packet'. 'packet' must be a valid TCP packet
+ * with its l4 marker properly populated. */
+void
+packet_set_tcp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
+{
+ struct tcp_header *th = packet->l4;
+
+ packet_set_port(&th->tcp_src, src, &th->tcp_csum);
+ packet_set_port(&th->tcp_dst, dst, &th->tcp_csum);
+}
+
+/* Sets the UDP source and destination port ('src' and 'dst' respectively) of
+ * the UDP header contained in 'packet'. 'packet' must be a valid UDP packet
+ * with its l4 marker properly populated. */
+void
+packet_set_udp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
+{
+ struct udp_header *uh = packet->l4;
+
+ if (uh->udp_csum) {
+ packet_set_port(&uh->udp_src, src, &uh->udp_csum);
+ packet_set_port(&uh->udp_dst, dst, &uh->udp_csum);
+
+ if (!uh->udp_csum) {
+ uh->udp_csum = htons(0xffff);
+ }
+ } else {
+ uh->udp_src = src;
+ uh->udp_dst = dst;
+ }
+}
+
+/* If 'packet' is a TCP packet, returns the TCP flags. Otherwise, returns 0.
+ *
+ * 'flow' must be the flow corresponding to 'packet' and 'packet''s header
+ * pointers must be properly initialized (e.g. with flow_extract()). */
+uint8_t
+packet_get_tcp_flags(const struct ofpbuf *packet, const struct flow *flow)
+{
+ if ((flow->dl_type == htons(ETH_TYPE_IP) ||
+ flow->dl_type == htons(ETH_TYPE_IPV6)) &&
+ flow->nw_proto == IPPROTO_TCP && packet->l7) {
+ const struct tcp_header *tcp = packet->l4;
+ return TCP_FLAGS(tcp->tcp_ctl);
+ } else {
+ return 0;
+ }
+}
+
+/* Appends a string representation of the TCP flags value 'tcp_flags'
+ * (e.g. obtained via packet_get_tcp_flags() or TCP_FLAGS) to 's', in the
+ * format used by tcpdump. */
+void
+packet_format_tcp_flags(struct ds *s, uint8_t tcp_flags)
+{
+ if (!tcp_flags) {
+ ds_put_cstr(s, "none");
+ return;
+ }
+
+ if (tcp_flags & TCP_SYN) {
+ ds_put_char(s, 'S');
+ }
+ if (tcp_flags & TCP_FIN) {
+ ds_put_char(s, 'F');
+ }
+ if (tcp_flags & TCP_PSH) {
+ ds_put_char(s, 'P');
+ }
+ if (tcp_flags & TCP_RST) {
+ ds_put_char(s, 'R');
+ }
+ if (tcp_flags & TCP_URG) {
+ ds_put_char(s, 'U');
+ }
+ if (tcp_flags & TCP_ACK) {
+ ds_put_char(s, '.');
+ }
+ if (tcp_flags & 0x40) {
+ ds_put_cstr(s, "[40]");
+ }
+ if (tcp_flags & 0x80) {
+ ds_put_cstr(s, "[80]");
+ }
+}