/*
- * Copyright (c) 2009, 2010, 2011 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "packets.h"
#include <assert.h>
#include <arpa/inet.h>
+#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include "byte-order.h"
+#include "csum.h"
+#include "flow.h"
#include "dynamic-string.h"
#include "ofpbuf.h"
memcpy(payload + tag_size, eth_src, ETH_ADDR_LEN);
}
-/* Modify the TCI field of 'packet', whose data must begin with an Ethernet
- * header. If a VLAN tag is present, its TCI field is replaced by 'tci'. If a
- * VLAN tag is not present, one is added with the TCI field set to 'tci'.
+/* Insert VLAN header according to given TCI. Packet passed must be Ethernet
+ * packet. Ignores the CFI bit of 'tci' using 0 instead.
*
* Also sets 'packet->l2' to point to the new Ethernet header. */
void
-eth_set_vlan_tci(struct ofpbuf *packet, ovs_be16 tci)
+eth_push_vlan(struct ofpbuf *packet, ovs_be16 tci)
{
struct eth_header *eh = packet->data;
struct vlan_eth_header *veh;
- if (packet->size >= sizeof(struct vlan_eth_header)
- && eh->eth_type == htons(ETH_TYPE_VLAN)) {
- veh = packet->data;
- veh->veth_tci = tci;
- } else {
- /* Insert new 802.1Q header. */
- struct vlan_eth_header tmp;
- memcpy(tmp.veth_dst, eh->eth_dst, ETH_ADDR_LEN);
- memcpy(tmp.veth_src, eh->eth_src, ETH_ADDR_LEN);
- tmp.veth_type = htons(ETH_TYPE_VLAN);
- tmp.veth_tci = tci;
- tmp.veth_next_type = eh->eth_type;
-
- veh = ofpbuf_push_uninit(packet, VLAN_HEADER_LEN);
- memcpy(veh, &tmp, sizeof tmp);
- }
+ /* Insert new 802.1Q header. */
+ struct vlan_eth_header tmp;
+ memcpy(tmp.veth_dst, eh->eth_dst, ETH_ADDR_LEN);
+ memcpy(tmp.veth_src, eh->eth_src, ETH_ADDR_LEN);
+ tmp.veth_type = htons(ETH_TYPE_VLAN);
+ tmp.veth_tci = tci & htons(~VLAN_CFI);
+ tmp.veth_next_type = eh->eth_type;
+
+ veh = ofpbuf_push_uninit(packet, VLAN_HEADER_LEN);
+ memcpy(veh, &tmp, sizeof tmp);
+
packet->l2 = packet->data;
}
+/* Removes outermost VLAN header (if any is present) from 'packet'.
+ *
+ * 'packet->l2' must initially point to 'packet''s Ethernet header. */
+void
+eth_pop_vlan(struct ofpbuf *packet)
+{
+ struct vlan_eth_header *veh = packet->l2;
+ if (packet->size >= sizeof *veh
+ && veh->veth_type == htons(ETH_TYPE_VLAN)) {
+ struct eth_header tmp;
+
+ memcpy(tmp.eth_dst, veh->veth_dst, ETH_ADDR_LEN);
+ memcpy(tmp.eth_src, veh->veth_src, ETH_ADDR_LEN);
+ tmp.eth_type = veh->veth_next_type;
+
+ ofpbuf_pull(packet, VLAN_HEADER_LEN);
+ packet->l2 = (char*)packet->l2 + VLAN_HEADER_LEN;
+ memcpy(packet->data, &tmp, sizeof tmp);
+ }
+}
+
+/* Converts hex digits in 'hex' to an Ethernet packet in '*packetp'. The
+ * caller must free '*packetp'. On success, returns NULL. On failure, returns
+ * an error message and stores NULL in '*packetp'. */
+const char *
+eth_from_hex(const char *hex, struct ofpbuf **packetp)
+{
+ struct ofpbuf *packet;
+
+ packet = *packetp = ofpbuf_new(strlen(hex) / 2);
+
+ if (ofpbuf_put_hex(packet, hex, NULL)[0] != '\0') {
+ ofpbuf_delete(packet);
+ *packetp = NULL;
+ return "Trailing garbage in packet data";
+ }
+
+ if (packet->size < ETH_HEADER_LEN) {
+ ofpbuf_delete(packet);
+ *packetp = NULL;
+ return "Packet data too short for Ethernet";
+ }
+
+ return NULL;
+}
+
+/* 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()). */
+int
+ip_count_cidr_bits(ovs_be32 netmask)
+{
+ assert(ip_is_cidr(netmask));
+ return 32 - ctz(ntohl(netmask));
+}
+
+void
+ip_format_masked(ovs_be32 ip, ovs_be32 mask, struct ds *s)
+{
+ ds_put_format(s, IP_FMT, IP_ARGS(&ip));
+ if (mask != htonl(UINT32_MAX)) {
+ if (ip_is_cidr(mask)) {
+ ds_put_format(s, "/%d", ip_count_cidr_bits(mask));
+ } else {
+ ds_put_format(s, "/"IP_FMT, IP_ARGS(&mask));
+ }
+ }
+}
+
+
/* Stores the string representation of the IPv6 address 'addr' into the
* character array 'addr_str', which must be at least INET6_ADDRSTRLEN
* bytes long. */
void
print_ipv6_addr(struct ds *string, const struct in6_addr *addr)
{
- char addr_str[INET6_ADDRSTRLEN];
+ char *dst;
- format_ipv6_addr(addr_str, addr);
- ds_put_format(string, "%s", addr_str);
+ ds_reserve(string, string->length + INET6_ADDRSTRLEN);
+
+ dst = string->string + string->length;
+ format_ipv6_addr(dst, addr);
+ string->length += strlen(dst);
+}
+
+void
+print_ipv6_masked(struct ds *s, const struct in6_addr *addr,
+ const struct in6_addr *mask)
+{
+ print_ipv6_addr(s, addr);
+ if (mask && !ipv6_mask_is_exact(mask)) {
+ if (ipv6_is_cidr(mask)) {
+ int cidr_bits = ipv6_count_cidr_bits(mask);
+ ds_put_format(s, "/%d", cidr_bits);
+ } else {
+ ds_put_char(s, '/');
+ print_ipv6_addr(s, mask);
+ }
+ }
}
struct in6_addr ipv6_addr_bitand(const struct in6_addr *a,
return netmask;
}
-/* Given the IPv6 netmask 'netmask', returns the number of bits of the
- * IPv6 address that it wildcards. 'netmask' must be a CIDR netmask (see
- * ipv6_is_cidr()). */
+/* Given the IPv6 netmask 'netmask', returns the number of bits of the IPv6
+ * address that it specifies, that is, the number of 1-bits in 'netmask'.
+ * 'netmask' must be a CIDR netmask (see ipv6_is_cidr()). */
int
ipv6_count_cidr_bits(const struct in6_addr *netmask)
{
/* Populates 'b' with an Ethernet II packet headed with the given 'eth_dst',
* 'eth_src' and 'eth_type' parameters. A payload of 'size' bytes is allocated
* in 'b' and returned. This payload may be populated with appropriate
- * information by the caller. */
+ * information by the caller. Sets 'b''s 'l2' and 'l3' pointers to the
+ * Ethernet header and payload respectively.
+ *
+ * The returned packet has enough headroom to insert an 802.1Q VLAN header if
+ * desired. */
void *
eth_compose(struct ofpbuf *b, const uint8_t eth_dst[ETH_ADDR_LEN],
const uint8_t eth_src[ETH_ADDR_LEN], uint16_t eth_type,
ofpbuf_clear(b);
- ofpbuf_prealloc_tailroom(b, ETH_HEADER_LEN + size);
+ ofpbuf_prealloc_tailroom(b, ETH_HEADER_LEN + VLAN_HEADER_LEN + size);
+ ofpbuf_reserve(b, VLAN_HEADER_LEN);
eth = ofpbuf_put_uninit(b, ETH_HEADER_LEN);
data = ofpbuf_put_uninit(b, size);
memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
eth->eth_type = htons(eth_type);
+ b->l2 = eth;
+ b->l3 = data;
+
return data;
}
/* Populates 'b' with an Ethernet LLC+SNAP packet headed with the given
* 'eth_dst', 'eth_src', 'snap_org', and 'snap_type'. A payload of 'size'
* bytes is allocated in 'b' and returned. This payload may be populated with
- * appropriate information by the caller. */
+ * appropriate information by the caller.
+ *
+ * The returned packet has enough headroom to insert an 802.1Q VLAN header if
+ * desired. */
void *
snap_compose(struct ofpbuf *b, const uint8_t eth_dst[ETH_ADDR_LEN],
const uint8_t eth_src[ETH_ADDR_LEN],
/* Compose basic packet structure. (We need the payload size to stick into
* the 802.2 header.) */
ofpbuf_clear(b);
- ofpbuf_prealloc_tailroom(b, ETH_HEADER_LEN + LLC_SNAP_HEADER_LEN + size);
+ ofpbuf_prealloc_tailroom(b, ETH_HEADER_LEN + VLAN_HEADER_LEN
+ + LLC_SNAP_HEADER_LEN + size);
+ ofpbuf_reserve(b, VLAN_HEADER_LEN);
eth = ofpbuf_put_zeros(b, ETH_HEADER_LEN);
llc_snap = ofpbuf_put_zeros(b, LLC_SNAP_HEADER_LEN);
payload = ofpbuf_put_uninit(b, size);
return payload;
}
-/* Populates 'pdu' with a LACP PDU comprised of 'actor' and 'partner'. */
+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
-compose_lacp_pdu(const struct lacp_info *actor,
- const struct lacp_info *partner, struct lacp_pdu *pdu)
+packet_set_ipv4(struct ofpbuf *packet, ovs_be32 src, ovs_be32 dst,
+ uint8_t tos, uint8_t ttl)
{
- memset(pdu, 0, sizeof *pdu);
+ struct ip_header *nh = packet->l3;
- pdu->subtype = 1;
- pdu->version = 1;
+ if (nh->ip_src != src) {
+ packet_set_ipv4_addr(packet, &nh->ip_src, src);
+ }
- pdu->actor_type = 1;
- pdu->actor_len = 20;
- pdu->actor = *actor;
+ 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;
+ }
- pdu->partner_type = 2;
- pdu->partner_len = 20;
- pdu->partner = *partner;
+ if (nh->ip_ttl != ttl) {
+ uint8_t *field = &nh->ip_ttl;
- pdu->collector_type = 3;
- pdu->collector_len = 16;
- pdu->collector_delay = htons(0);
+ 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);
}
-/* Parses 'b' which represents a packet containing a LACP PDU. This function
- * returns NULL if 'b' is malformed, or does not represent a LACP PDU format
- * supported by OVS. Otherwise, it returns a pointer to the lacp_pdu contained
- * within 'b'. */
-const struct lacp_pdu *
-parse_lacp_packet(const struct ofpbuf *b)
+/* 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)
{
- const struct lacp_pdu *pdu;
+ struct udp_header *uh = packet->l4;
- pdu = ofpbuf_at(b, (uint8_t *)b->l3 - (uint8_t *)b->data, LACP_PDU_LEN);
+ 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 (pdu && pdu->subtype == 1
- && pdu->actor_type == 1 && pdu->actor_len == 20
- && pdu->partner_type == 2 && pdu->partner_len == 20) {
- return pdu;
+ 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)
+{
+ /* XXX IPv6? */
+ if (flow->dl_type == htons(ETH_TYPE_IP) && packet->l4
+ && flow->nw_proto == IPPROTO_TCP && packet->l7) {
+ const struct tcp_header *tcp = packet->l4;
+ return TCP_FLAGS(tcp->tcp_ctl);
} else {
- return NULL;
+ return 0;
}
}