#include "flow.h"
#include "hmap.h"
#include "dynamic-string.h"
-#include "ofpbuf.h"
#include "ovs-thread.h"
#include "odp-util.h"
+#include "dp-packet.h"
#include "unaligned.h"
const struct in6_addr in6addr_exact = IN6ADDR_EXACT_INIT;
* The returned packet has enough headroom to insert an 802.1Q VLAN header if
* desired. */
void
-compose_rarp(struct ofpbuf *b, const uint8_t eth_src[ETH_ADDR_LEN])
+compose_rarp(struct dp_packet *b, const uint8_t eth_src[ETH_ADDR_LEN])
{
struct eth_header *eth;
struct arp_eth_header *arp;
- ofpbuf_clear(b);
- ofpbuf_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN
+ dp_packet_clear(b);
+ dp_packet_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN
+ ARP_ETH_HEADER_LEN);
- ofpbuf_reserve(b, 2 + VLAN_HEADER_LEN);
- eth = ofpbuf_put_uninit(b, sizeof *eth);
+ dp_packet_reserve(b, 2 + VLAN_HEADER_LEN);
+ eth = dp_packet_put_uninit(b, sizeof *eth);
memcpy(eth->eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
eth->eth_type = htons(ETH_TYPE_RARP);
- arp = ofpbuf_put_uninit(b, sizeof *arp);
+ arp = dp_packet_put_uninit(b, sizeof *arp);
arp->ar_hrd = htons(ARP_HRD_ETHERNET);
arp->ar_pro = htons(ARP_PRO_IP);
arp->ar_hln = sizeof arp->ar_sha;
memcpy(arp->ar_tha, eth_src, ETH_ADDR_LEN);
put_16aligned_be32(&arp->ar_tpa, htonl(0));
- ofpbuf_set_frame(b, eth);
- ofpbuf_set_l3(b, arp);
+ dp_packet_set_frame(b, eth);
+ dp_packet_set_l3(b, arp);
}
/* Insert VLAN header according to given TCI. Packet passed must be Ethernet
*
* Also adjusts the layer offsets accordingly. */
void
-eth_push_vlan(struct ofpbuf *packet, ovs_be16 tpid, ovs_be16 tci)
+eth_push_vlan(struct dp_packet *packet, ovs_be16 tpid, ovs_be16 tci)
{
struct vlan_eth_header *veh;
/* Insert new 802.1Q header. */
- veh = ofpbuf_resize_l2(packet, VLAN_HEADER_LEN);
+ veh = dp_packet_resize_l2(packet, VLAN_HEADER_LEN);
memmove(veh, (char *)veh + VLAN_HEADER_LEN, 2 * ETH_ADDR_LEN);
veh->veth_type = tpid;
veh->veth_tci = tci & htons(~VLAN_CFI);
* 'packet->l2_5' should initially point to 'packet''s outer-most MPLS header
* or may be NULL if there are no MPLS headers. */
void
-eth_pop_vlan(struct ofpbuf *packet)
+eth_pop_vlan(struct dp_packet *packet)
{
- struct vlan_eth_header *veh = ofpbuf_l2(packet);
+ struct vlan_eth_header *veh = dp_packet_l2(packet);
- if (veh && ofpbuf_size(packet) >= sizeof *veh
+ if (veh && dp_packet_size(packet) >= sizeof *veh
&& veh->veth_type == htons(ETH_TYPE_VLAN)) {
memmove((char *)veh + VLAN_HEADER_LEN, veh, 2 * ETH_ADDR_LEN);
- ofpbuf_resize_l2(packet, -VLAN_HEADER_LEN);
+ dp_packet_resize_l2(packet, -VLAN_HEADER_LEN);
}
}
/* Set ethertype of the packet. */
static void
-set_ethertype(struct ofpbuf *packet, ovs_be16 eth_type)
+set_ethertype(struct dp_packet *packet, ovs_be16 eth_type)
{
- struct eth_header *eh = ofpbuf_l2(packet);
+ struct eth_header *eh = dp_packet_l2(packet);
if (!eh) {
return;
if (eh->eth_type == htons(ETH_TYPE_VLAN)) {
ovs_be16 *p;
- char *l2_5 = ofpbuf_l2_5(packet);
+ char *l2_5 = dp_packet_l2_5(packet);
p = ALIGNED_CAST(ovs_be16 *,
- (l2_5 ? l2_5 : (char *)ofpbuf_l3(packet)) - 2);
+ (l2_5 ? l2_5 : (char *)dp_packet_l3(packet)) - 2);
*p = eth_type;
} else {
eh->eth_type = eth_type;
}
}
-static bool is_mpls(struct ofpbuf *packet)
+static bool is_mpls(struct dp_packet *packet)
{
return packet->l2_5_ofs != UINT16_MAX;
}
/* Set MPLS label stack entry to outermost MPLS header.*/
void
-set_mpls_lse(struct ofpbuf *packet, ovs_be32 mpls_lse)
+set_mpls_lse(struct dp_packet *packet, ovs_be32 mpls_lse)
{
/* Packet type should be MPLS to set label stack entry. */
if (is_mpls(packet)) {
- struct mpls_hdr *mh = ofpbuf_l2_5(packet);
+ struct mpls_hdr *mh = dp_packet_l2_5(packet);
/* Update mpls label stack entry. */
put_16aligned_be32(&mh->mpls_lse, mpls_lse);
* header. If 'packet' does not already have any MPLS labels, then its
* Ethertype is changed to 'ethtype' (which must be an MPLS Ethertype). */
void
-push_mpls(struct ofpbuf *packet, ovs_be16 ethtype, ovs_be32 lse)
+push_mpls(struct dp_packet *packet, ovs_be16 ethtype, ovs_be32 lse)
{
char * header;
size_t len;
/* Push new MPLS shim header onto packet. */
len = packet->l2_5_ofs;
- header = ofpbuf_resize_l2_5(packet, MPLS_HLEN);
+ header = dp_packet_resize_l2_5(packet, MPLS_HLEN);
memmove(header, header + MPLS_HLEN, len);
memcpy(header + len, &lse, sizeof lse);
}
* Ethertype to 'ethtype' (which ordinarily should not be an MPLS
* Ethertype). */
void
-pop_mpls(struct ofpbuf *packet, ovs_be16 ethtype)
+pop_mpls(struct dp_packet *packet, ovs_be16 ethtype)
{
if (is_mpls(packet)) {
- struct mpls_hdr *mh = ofpbuf_l2_5(packet);
+ struct mpls_hdr *mh = dp_packet_l2_5(packet);
size_t len = packet->l2_5_ofs;
set_ethertype(packet, ethtype);
if (get_16aligned_be32(&mh->mpls_lse) & htonl(MPLS_BOS_MASK)) {
- ofpbuf_set_l2_5(packet, NULL);
+ dp_packet_set_l2_5(packet, NULL);
}
/* Shift the l2 header forward. */
- memmove((char*)ofpbuf_data(packet) + MPLS_HLEN, ofpbuf_data(packet), len);
- ofpbuf_resize_l2_5(packet, -MPLS_HLEN);
+ memmove((char*)dp_packet_data(packet) + MPLS_HLEN, dp_packet_data(packet), len);
+ dp_packet_resize_l2_5(packet, -MPLS_HLEN);
}
}
*
* Aligns the L3 header of '*packetp' on a 32-bit boundary. */
const char *
-eth_from_hex(const char *hex, struct ofpbuf **packetp)
+eth_from_hex(const char *hex, struct dp_packet **packetp)
{
- struct ofpbuf *packet;
+ struct dp_packet *packet;
/* Use 2 bytes of headroom to 32-bit align the L3 header. */
- packet = *packetp = ofpbuf_new_with_headroom(strlen(hex) / 2, 2);
+ packet = *packetp = dp_packet_new_with_headroom(strlen(hex) / 2, 2);
- if (ofpbuf_put_hex(packet, hex, NULL)[0] != '\0') {
- ofpbuf_delete(packet);
+ if (dp_packet_put_hex(packet, hex, NULL)[0] != '\0') {
+ dp_packet_delete(packet);
*packetp = NULL;
return "Trailing garbage in packet data";
}
- if (ofpbuf_size(packet) < ETH_HEADER_LEN) {
- ofpbuf_delete(packet);
+ if (dp_packet_size(packet) < ETH_HEADER_LEN) {
+ dp_packet_delete(packet);
*packetp = NULL;
return "Packet data too short for Ethernet";
}
* 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],
+eth_compose(struct dp_packet *b, const uint8_t eth_dst[ETH_ADDR_LEN],
const uint8_t eth_src[ETH_ADDR_LEN], uint16_t eth_type,
size_t size)
{
void *data;
struct eth_header *eth;
- ofpbuf_clear(b);
+ dp_packet_clear(b);
/* The magic 2 here ensures that the L3 header (when it is added later)
* will be 32-bit aligned. */
- ofpbuf_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN + size);
- ofpbuf_reserve(b, 2 + VLAN_HEADER_LEN);
- eth = ofpbuf_put_uninit(b, ETH_HEADER_LEN);
- data = ofpbuf_put_uninit(b, size);
+ dp_packet_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN + size);
+ dp_packet_reserve(b, 2 + VLAN_HEADER_LEN);
+ eth = dp_packet_put_uninit(b, ETH_HEADER_LEN);
+ data = dp_packet_put_uninit(b, size);
memcpy(eth->eth_dst, eth_dst, ETH_ADDR_LEN);
memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
eth->eth_type = htons(eth_type);
- ofpbuf_set_frame(b, eth);
- ofpbuf_set_l3(b, data);
+ dp_packet_set_frame(b, eth);
+ dp_packet_set_l3(b, data);
return data;
}
static void
-packet_set_ipv4_addr(struct ofpbuf *packet,
+packet_set_ipv4_addr(struct dp_packet *packet,
ovs_16aligned_be32 *addr, ovs_be32 new_addr)
{
- struct ip_header *nh = ofpbuf_l3(packet);
+ struct ip_header *nh = dp_packet_l3(packet);
ovs_be32 old_addr = get_16aligned_be32(addr);
- size_t l4_size = ofpbuf_l4_size(packet);
+ size_t l4_size = dp_packet_l4_size(packet);
if (nh->ip_proto == IPPROTO_TCP && l4_size >= TCP_HEADER_LEN) {
- struct tcp_header *th = ofpbuf_l4(packet);
+ struct tcp_header *th = dp_packet_l4(packet);
th->tcp_csum = recalc_csum32(th->tcp_csum, old_addr, new_addr);
} else if (nh->ip_proto == IPPROTO_UDP && l4_size >= UDP_HEADER_LEN ) {
- struct udp_header *uh = ofpbuf_l4(packet);
+ struct udp_header *uh = dp_packet_l4(packet);
if (uh->udp_csum) {
uh->udp_csum = recalc_csum32(uh->udp_csum, old_addr, new_addr);
*
* This function assumes that L3 and L4 offsets are set in the packet. */
static bool
-packet_rh_present(struct ofpbuf *packet)
+packet_rh_present(struct dp_packet *packet)
{
const struct ovs_16aligned_ip6_hdr *nh;
int nexthdr;
size_t len;
size_t remaining;
- uint8_t *data = ofpbuf_l3(packet);
+ uint8_t *data = dp_packet_l3(packet);
remaining = packet->l4_ofs - packet->l3_ofs;
}
static void
-packet_update_csum128(struct ofpbuf *packet, uint8_t proto,
+packet_update_csum128(struct dp_packet *packet, uint8_t proto,
ovs_16aligned_be32 addr[4], const ovs_be32 new_addr[4])
{
- size_t l4_size = ofpbuf_l4_size(packet);
+ size_t l4_size = dp_packet_l4_size(packet);
if (proto == IPPROTO_TCP && l4_size >= TCP_HEADER_LEN) {
- struct tcp_header *th = ofpbuf_l4(packet);
+ struct tcp_header *th = dp_packet_l4(packet);
th->tcp_csum = recalc_csum128(th->tcp_csum, addr, new_addr);
} else if (proto == IPPROTO_UDP && l4_size >= UDP_HEADER_LEN) {
- struct udp_header *uh = ofpbuf_l4(packet);
+ struct udp_header *uh = dp_packet_l4(packet);
if (uh->udp_csum) {
uh->udp_csum = recalc_csum128(uh->udp_csum, addr, new_addr);
}
} else if (proto == IPPROTO_ICMPV6 &&
l4_size >= sizeof(struct icmp6_header)) {
- struct icmp6_header *icmp = ofpbuf_l4(packet);
+ struct icmp6_header *icmp = dp_packet_l4(packet);
icmp->icmp6_cksum = recalc_csum128(icmp->icmp6_cksum, addr, new_addr);
}
}
static void
-packet_set_ipv6_addr(struct ofpbuf *packet, uint8_t proto,
+packet_set_ipv6_addr(struct dp_packet *packet, uint8_t proto,
ovs_16aligned_be32 addr[4], const ovs_be32 new_addr[4],
bool recalculate_csum)
{
* '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,
+packet_set_ipv4(struct dp_packet *packet, ovs_be32 src, ovs_be32 dst,
uint8_t tos, uint8_t ttl)
{
- struct ip_header *nh = ofpbuf_l3(packet);
+ struct ip_header *nh = dp_packet_l3(packet);
if (get_16aligned_be32(&nh->ip_src) != src) {
packet_set_ipv4_addr(packet, &nh->ip_src, src);
* appropriate. 'packet' must contain a valid IPv6 packet with correctly
* populated l[34] offsets. */
void
-packet_set_ipv6(struct ofpbuf *packet, uint8_t proto, const ovs_be32 src[4],
+packet_set_ipv6(struct dp_packet *packet, uint8_t proto, const ovs_be32 src[4],
const ovs_be32 dst[4], uint8_t key_tc, ovs_be32 key_fl,
uint8_t key_hl)
{
- struct ovs_16aligned_ip6_hdr *nh = ofpbuf_l3(packet);
+ struct ovs_16aligned_ip6_hdr *nh = dp_packet_l3(packet);
if (memcmp(&nh->ip6_src, src, sizeof(ovs_be32[4]))) {
packet_set_ipv6_addr(packet, proto, nh->ip6_src.be32, src, true);
* the TCP header contained in 'packet'. 'packet' must be a valid TCP packet
* with its l4 offset properly populated. */
void
-packet_set_tcp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
+packet_set_tcp_port(struct dp_packet *packet, ovs_be16 src, ovs_be16 dst)
{
- struct tcp_header *th = ofpbuf_l4(packet);
+ struct tcp_header *th = dp_packet_l4(packet);
packet_set_port(&th->tcp_src, src, &th->tcp_csum);
packet_set_port(&th->tcp_dst, dst, &th->tcp_csum);
* the UDP header contained in 'packet'. 'packet' must be a valid UDP packet
* with its l4 offset properly populated. */
void
-packet_set_udp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
+packet_set_udp_port(struct dp_packet *packet, ovs_be16 src, ovs_be16 dst)
{
- struct udp_header *uh = ofpbuf_l4(packet);
+ struct udp_header *uh = dp_packet_l4(packet);
if (uh->udp_csum) {
packet_set_port(&uh->udp_src, src, &uh->udp_csum);
* the SCTP header contained in 'packet'. 'packet' must be a valid SCTP packet
* with its l4 offset properly populated. */
void
-packet_set_sctp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
+packet_set_sctp_port(struct dp_packet *packet, ovs_be16 src, ovs_be16 dst)
{
- struct sctp_header *sh = ofpbuf_l4(packet);
+ struct sctp_header *sh = dp_packet_l4(packet);
ovs_be32 old_csum, old_correct_csum, new_csum;
- uint16_t tp_len = ofpbuf_l4_size(packet);
+ uint16_t tp_len = dp_packet_l4_size(packet);
old_csum = get_16aligned_be32(&sh->sctp_csum);
put_16aligned_be32(&sh->sctp_csum, 0);
}
void
-packet_set_nd(struct ofpbuf *packet, const ovs_be32 target[4],
+packet_set_nd(struct dp_packet *packet, const ovs_be32 target[4],
const uint8_t sll[ETH_ADDR_LEN],
const uint8_t tll[ETH_ADDR_LEN]) {
struct ovs_nd_msg *ns;
struct ovs_nd_opt *nd_opt;
- int bytes_remain = ofpbuf_l4_size(packet);
+ int bytes_remain = dp_packet_l4_size(packet);
if (OVS_UNLIKELY(bytes_remain < sizeof(*ns))) {
return;
}
- ns = ofpbuf_l4(packet);
+ ns = dp_packet_l4(packet);
nd_opt = &ns->options[0];
bytes_remain -= sizeof(*ns);
ARP_ETH_HEADER_LEN)
void
-compose_arp(struct ofpbuf *b, const uint8_t eth_src[ETH_ADDR_LEN],
+compose_arp(struct dp_packet *b, const uint8_t eth_src[ETH_ADDR_LEN],
ovs_be32 ip_src, ovs_be32 ip_dst)
{
struct eth_header *eth;
struct arp_eth_header *arp;
- ofpbuf_clear(b);
- ofpbuf_prealloc_tailroom(b, ARP_PACKET_SIZE);
- ofpbuf_reserve(b, 2 + VLAN_HEADER_LEN);
+ dp_packet_clear(b);
+ dp_packet_prealloc_tailroom(b, ARP_PACKET_SIZE);
+ dp_packet_reserve(b, 2 + VLAN_HEADER_LEN);
- eth = ofpbuf_put_uninit(b, sizeof *eth);
+ eth = dp_packet_put_uninit(b, sizeof *eth);
memcpy(eth->eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
eth->eth_type = htons(ETH_TYPE_ARP);
- arp = ofpbuf_put_uninit(b, sizeof *arp);
+ arp = dp_packet_put_uninit(b, sizeof *arp);
arp->ar_hrd = htons(ARP_HRD_ETHERNET);
arp->ar_pro = htons(ARP_PRO_IP);
arp->ar_hln = sizeof arp->ar_sha;
put_16aligned_be32(&arp->ar_spa, ip_src);
put_16aligned_be32(&arp->ar_tpa, ip_dst);
- ofpbuf_set_frame(b, eth);
- ofpbuf_set_l3(b, arp);
+ dp_packet_set_frame(b, eth);
+ dp_packet_set_l3(b, arp);
}
projects / cascardo / ovs.git / blobdiff