ofpbuf: Introduce access api for base, data and size.

These functions will be used by later patches.  Following patch
does not change functionality.

Signed-off-by: Pravin B Shelar <pshelar@nicira.com>

54 files changed, 728 insertions, 673 deletions

diff --git a/lib/bfd.c b/lib/bfd.c
index cc9e4535c..8bfe38584 100644
--- a/lib/bfd.c
+++ b/lib/bfd.c
@@ -673,7 +673,7 @@ bfd_process_packet(struct bfd *bfd, const struct flow *flow,
         goto out;
     }
 
-    msg = ofpbuf_at(p, l7 - (uint8_t *)p->data, BFD_PACKET_LEN);
+    msg = ofpbuf_at(p, l7 - (uint8_t *)ofpbuf_data(p), BFD_PACKET_LEN);
     if (!msg) {
         VLOG_INFO_RL(&rl, "%s: Received too-short BFD control message (only "
                      "%"PRIdPTR" bytes long, at least %d required).",
diff --git a/lib/cfm.c b/lib/cfm.c
index dcdaa0ea6..420a57f10 100644
--- a/lib/cfm.c
+++ b/lib/cfm.c
@@ -719,7 +719,7 @@ cfm_process_heartbeat(struct cfm *cfm, const struct ofpbuf *p)
     ovs_mutex_lock(&mutex);
 
     eth = p->l2;
-    ccm = ofpbuf_at(p, (uint8_t *)ofpbuf_get_l3(p) - (uint8_t *)p->data,
+    ccm = ofpbuf_at(p, (uint8_t *)ofpbuf_get_l3(p) - (uint8_t *)ofpbuf_data(p),
                     CCM_ACCEPT_LEN);
 
     if (!ccm) {
diff --git a/lib/dpif-linux.c b/lib/dpif-linux.c
index 779f764e6..e8efdacc5 100644
--- a/lib/dpif-linux.c
+++ b/lib/dpif-linux.c
@@ -542,8 +542,8 @@ dpif_linux_port_add__(struct dpif *dpif_, struct netdev *netdev,
         ofpbuf_use_stack(&options, options_stub, sizeof options_stub);
         nl_msg_put_u16(&options, OVS_TUNNEL_ATTR_DST_PORT,
                        ntohs(tnl_cfg->dst_port));
-        request.options = options.data;
-        request.options_len = options.size;
+        request.options = ofpbuf_data(&options);
+        request.options_len = ofpbuf_size(&options);
     }
 
     request.port_no = *port_nop;
@@ -906,8 +906,8 @@ dpif_linux_flow_get(const struct dpif *dpif_,
             dpif_linux_flow_get_stats(&reply, stats);
         }
         if (actionsp) {
-            buf->data = CONST_CAST(struct nlattr *, reply.actions);
-            buf->size = reply.actions_len;
+            ofpbuf_set_data(buf, CONST_CAST(struct nlattr *, reply.actions));
+            ofpbuf_set_size(buf, reply.actions_len);
             *actionsp = buf;
         } else {
             ofpbuf_delete(buf);
@@ -1110,7 +1110,7 @@ dpif_linux_flow_dump_next_may_destroy_keys(void *state_)
 {
     struct dpif_linux_flow_state *state = state_;
 
-    return state->buffer.size ? false : true;
+    return ofpbuf_size(&state->buffer) ? false : true;
 }
 
 static int
@@ -1133,7 +1133,7 @@ dpif_linux_encode_execute(int dp_ifindex, const struct dpif_execute *d_exec,
     size_t key_ofs;
 
     ofpbuf_prealloc_tailroom(buf, (64
-                                   + d_exec->packet->size
+                                   + ofpbuf_size(d_exec->packet)
                                    + ODP_KEY_METADATA_SIZE
                                    + d_exec->actions_len));
 
@@ -1144,7 +1144,8 @@ dpif_linux_encode_execute(int dp_ifindex, const struct dpif_execute *d_exec,
     k_exec->dp_ifindex = dp_ifindex;
 
     nl_msg_put_unspec(buf, OVS_PACKET_ATTR_PACKET,
-                      d_exec->packet->data, d_exec->packet->size);
+                      ofpbuf_data(d_exec->packet),
+                      ofpbuf_size(d_exec->packet));
 
     key_ofs = nl_msg_start_nested(buf, OVS_PACKET_ATTR_KEY);
     odp_key_from_pkt_metadata(buf, &d_exec->md);
@@ -1500,7 +1501,7 @@ parse_odp_packet(struct ofpbuf *buf, struct dpif_upcall *upcall,
     struct ofpbuf b;
     int type;
 
-    ofpbuf_use_const(&b, buf->data, buf->size);
+    ofpbuf_use_const(&b, ofpbuf_data(buf), ofpbuf_size(buf));
 
     nlmsg = ofpbuf_try_pull(&b, sizeof *nlmsg);
     genl = ofpbuf_try_pull(&b, sizeof *genl);
@@ -1532,8 +1533,9 @@ parse_odp_packet(struct ofpbuf *buf, struct dpif_upcall *upcall,
                                nl_attr_get(a[OVS_PACKET_ATTR_PACKET])) - 1,
                     nl_attr_get_size(a[OVS_PACKET_ATTR_PACKET]) +
                     sizeof(struct nlattr));
-    upcall->packet.data = (char *)upcall->packet.data + sizeof(struct nlattr);
-    upcall->packet.size = nl_attr_get_size(a[OVS_PACKET_ATTR_PACKET]);
+    ofpbuf_set_data(&upcall->packet,
+                    (char *)ofpbuf_data(&upcall->packet) + sizeof(struct nlattr));
+    ofpbuf_set_size(&upcall->packet, nl_attr_get_size(a[OVS_PACKET_ATTR_PACKET]));
 
     *dp_ifindex = ovs_header->dp_ifindex;
 
@@ -1778,7 +1780,7 @@ dpif_linux_vport_from_ofpbuf(struct dpif_linux_vport *vport,
 
     dpif_linux_vport_init(vport);
 
-    ofpbuf_use_const(&b, buf->data, buf->size);
+    ofpbuf_use_const(&b, ofpbuf_data(buf), ofpbuf_size(buf));
     nlmsg = ofpbuf_try_pull(&b, sizeof *nlmsg);
     genl = ofpbuf_try_pull(&b, sizeof *genl);
     ovs_header = ofpbuf_try_pull(&b, sizeof *ovs_header);
@@ -1941,7 +1943,7 @@ dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const struct ofpbuf *buf)
 
     dpif_linux_dp_init(dp);
 
-    ofpbuf_use_const(&b, buf->data, buf->size);
+    ofpbuf_use_const(&b, ofpbuf_data(buf), ofpbuf_size(buf));
     nlmsg = ofpbuf_try_pull(&b, sizeof *nlmsg);
     genl = ofpbuf_try_pull(&b, sizeof *genl);
     ovs_header = ofpbuf_try_pull(&b, sizeof *ovs_header);
@@ -2103,7 +2105,7 @@ dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *flow,
 
     dpif_linux_flow_init(flow);
 
-    ofpbuf_use_const(&b, buf->data, buf->size);
+    ofpbuf_use_const(&b, ofpbuf_data(buf), ofpbuf_size(buf));
     nlmsg = ofpbuf_try_pull(&b, sizeof *nlmsg);
     genl = ofpbuf_try_pull(&b, sizeof *genl);
     ovs_header = ofpbuf_try_pull(&b, sizeof *ovs_header);
diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c
index ceee233ad..5b9bfdbf4 100644
--- a/lib/dpif-netdev.c
+++ b/lib/dpif-netdev.c
@@ -1462,8 +1462,8 @@ dpif_netdev_flow_dump_next(const struct dpif *dpif, void *iter_, void *state_,
         odp_flow_key_from_flow(&buf, &netdev_flow->flow,
                                netdev_flow->flow.in_port.odp_port);
 
-        *key = buf.data;
-        *key_len = buf.size;
+        *key = ofpbuf_data(&buf);
+        *key_len = ofpbuf_size(&buf);
     }
 
     if (key && mask) {
@@ -1476,8 +1476,8 @@ dpif_netdev_flow_dump_next(const struct dpif *dpif, void *iter_, void *state_,
                                odp_to_u32(wc.masks.in_port.odp_port),
                                SIZE_MAX);
 
-        *mask = buf.data;
-        *mask_len = buf.size;
+        *mask = ofpbuf_data(&buf);
+        *mask_len = ofpbuf_size(&buf);
     }
 
     if (actions || stats) {
@@ -1515,8 +1515,8 @@ dpif_netdev_execute(struct dpif *dpif, struct dpif_execute *execute)
     struct pkt_metadata *md = &execute->md;
     struct flow key;
 
-    if (execute->packet->size < ETH_HEADER_LEN ||
-        execute->packet->size > UINT16_MAX) {
+    if (ofpbuf_size(execute->packet) < ETH_HEADER_LEN ||
+        ofpbuf_size(execute->packet) > UINT16_MAX) {
         return EINVAL;
     }
 
@@ -1966,7 +1966,7 @@ dp_netdev_flow_used(struct dp_netdev_flow *netdev_flow,
     ovs_mutex_lock(&bucket->mutex);
     bucket->used = MAX(now, bucket->used);
     bucket->packet_count++;
-    bucket->byte_count += packet->size;
+    bucket->byte_count += ofpbuf_size(packet);
     bucket->tcp_flags |= tcp_flags;
     ovs_mutex_unlock(&bucket->mutex);
 }
@@ -1997,7 +1997,7 @@ dp_netdev_port_input(struct dp_netdev *dp, struct ofpbuf *packet,
     struct dp_netdev_flow *netdev_flow;
     struct flow key;
 
-    if (packet->size < ETH_HEADER_LEN) {
+    if (ofpbuf_size(packet) < ETH_HEADER_LEN) {
         ofpbuf_delete(packet);
         return;
     }
@@ -2045,13 +2045,13 @@ dp_netdev_output_userspace(struct dp_netdev *dp, struct ofpbuf *packet,
         if (userdata) {
             buf_size += NLA_ALIGN(userdata->nla_len);
         }
-        buf_size += packet->size;
+        buf_size += ofpbuf_size(packet);
         ofpbuf_init(buf, buf_size);
 
         /* Put ODP flow. */
         odp_flow_key_from_flow(buf, flow, flow->in_port.odp_port);
-        upcall->key = buf->data;
-        upcall->key_len = buf->size;
+        upcall->key = ofpbuf_data(buf);
+        upcall->key_len = ofpbuf_size(buf);
 
         /* Put userdata. */
         if (userdata) {
@@ -2059,8 +2059,9 @@ dp_netdev_output_userspace(struct dp_netdev *dp, struct ofpbuf *packet,
                                           NLA_ALIGN(userdata->nla_len));
         }
 
-        upcall->packet.data = ofpbuf_put(buf, packet->data, packet->size);
-        upcall->packet.size = packet->size;
+        ofpbuf_set_data(&upcall->packet,
+                        ofpbuf_put(buf, ofpbuf_data(packet), ofpbuf_size(packet)));
+        ofpbuf_set_size(&upcall->packet, ofpbuf_size(packet));
 
         seq_change(q->seq);
 
diff --git a/lib/dpif-netdev.h b/lib/dpif-netdev.h
index 409678588..af4a969a2 100644
--- a/lib/dpif-netdev.h
+++ b/lib/dpif-netdev.h
@@ -34,8 +34,8 @@ enum { DP_NETDEV_HEADROOM = 2 + VLAN_HEADER_LEN };
 
 static inline void dp_packet_pad(struct ofpbuf *b)
 {
-    if (b->size < ETH_TOTAL_MIN) {
-        ofpbuf_put_zeros(b, ETH_TOTAL_MIN - b->size);
+    if (ofpbuf_size(b) < ETH_TOTAL_MIN) {
+        ofpbuf_put_zeros(b, ETH_TOTAL_MIN - ofpbuf_size(b));
     }
 }
 
diff --git a/lib/dpif.c b/lib/dpif.c
index 664917663..a8bd6745d 100644
--- a/lib/dpif.c
+++ b/lib/dpif.c
@@ -788,7 +788,7 @@ dpif_flow_stats_extract(const struct flow *flow, const struct ofpbuf *packet,
                         long long int used, struct dpif_flow_stats *stats)
 {
     stats->tcp_flags = ntohs(flow->tcp_flags);
-    stats->n_bytes = packet->size;
+    stats->n_bytes = ofpbuf_size(packet);
     stats->n_packets = 1;
     stats->used = used;
 }
@@ -861,8 +861,8 @@ dpif_flow_get(const struct dpif *dpif,
         size_t actions_len;
 
         if (!error && actionsp) {
-            actions = (*actionsp)->data;
-            actions_len = (*actionsp)->size;
+            actions = ofpbuf_data(*actionsp);
+            actions_len = ofpbuf_size(*actionsp);
         } else {
             actions = NULL;
             actions_len = 0;
@@ -1359,8 +1359,8 @@ dpif_recv(struct dpif *dpif, uint32_t handler_id, struct dpif_upcall *upcall,
         struct ds flow;
         char *packet;
 
-        packet = ofp_packet_to_string(upcall->packet.data,
-                                      upcall->packet.size);
+        packet = ofp_packet_to_string(ofpbuf_data(&upcall->packet),
+                                      ofpbuf_size(&upcall->packet));
 
         ds_init(&flow);
         odp_flow_key_format(upcall->key, upcall->key_len, &flow);
@@ -1563,8 +1563,8 @@ log_execute_message(struct dpif *dpif, const struct dpif_execute *execute,
         struct ds ds = DS_EMPTY_INITIALIZER;
         char *packet;
 
-        packet = ofp_packet_to_string(execute->packet->data,
-                                      execute->packet->size);
+        packet = ofp_packet_to_string(ofpbuf_data(execute->packet),
+                                      ofpbuf_size(execute->packet));
         ds_put_format(&ds, "%s: execute ", dpif_name(dpif));
         format_odp_actions(&ds, execute->actions, execute->actions_len);
         if (error) {
diff --git a/lib/flow.c b/lib/flow.c
index 314c1c768..60b667ca5 100644
--- a/lib/flow.c
+++ b/lib/flow.c
@@ -59,10 +59,10 @@ pull_arp(struct ofpbuf *packet)
 static struct ip_header *
 pull_ip(struct ofpbuf *packet)
 {
-    if (packet->size >= IP_HEADER_LEN) {
-        struct ip_header *ip = packet->data;
+    if (ofpbuf_size(packet) >= IP_HEADER_LEN) {
+        struct ip_header *ip = ofpbuf_data(packet);
         int ip_len = IP_IHL(ip->ip_ihl_ver) * 4;
-        if (ip_len >= IP_HEADER_LEN && packet->size >= ip_len) {
+        if (ip_len >= IP_HEADER_LEN && ofpbuf_size(packet) >= ip_len) {
             return ofpbuf_pull(packet, ip_len);
         }
     }
@@ -105,7 +105,7 @@ parse_vlan(struct ofpbuf *b, struct flow *flow)
         ovs_be16 tci;
     };
 
-    if (b->size >= sizeof(struct qtag_prefix) + sizeof(ovs_be16)) {
+    if (ofpbuf_size(b) >= sizeof(struct qtag_prefix) + sizeof(ovs_be16)) {
         struct qtag_prefix *qp = ofpbuf_pull(b, sizeof *qp);
         flow->vlan_tci = qp->tci | htons(VLAN_CFI);
     }
@@ -122,11 +122,11 @@ parse_ethertype(struct ofpbuf *b)
         return proto;
     }
 
-    if (b->size < sizeof *llc) {
+    if (ofpbuf_size(b) < sizeof *llc) {
         return htons(FLOW_DL_TYPE_NONE);
     }
 
-    llc = b->data;
+    llc = ofpbuf_data(b);
     if (llc->llc.llc_dsap != LLC_DSAP_SNAP
         || llc->llc.llc_ssap != LLC_SSAP_SNAP
         || llc->llc.llc_cntl != LLC_CNTL_SNAP
@@ -184,7 +184,7 @@ parse_ipv6(struct ofpbuf *packet, struct flow *flow)
          * accesses within the extension header are within those first 8
          * bytes. All extension headers are required to be at least 8
          * bytes. */
-        if (packet->size < 8) {
+        if (ofpbuf_size(packet) < 8) {
             return EINVAL;
         }
 
@@ -193,7 +193,7 @@ parse_ipv6(struct ofpbuf *packet, struct flow *flow)
                 || (nexthdr == IPPROTO_DSTOPTS)) {
             /* These headers, while different, have the fields we care about
              * in the same location and with the same interpretation. */
-            const struct ip6_ext *ext_hdr = packet->data;
+            const struct ip6_ext *ext_hdr = ofpbuf_data(packet);
             nexthdr = ext_hdr->ip6e_nxt;
             if (!ofpbuf_try_pull(packet, (ext_hdr->ip6e_len + 1) * 8)) {
                 return EINVAL;
@@ -203,13 +203,13 @@ parse_ipv6(struct ofpbuf *packet, struct flow *flow)
              * we care about are in the same location as the generic
              * option header--only the header length is calculated
              * differently. */
-            const struct ip6_ext *ext_hdr = packet->data;
+            const struct ip6_ext *ext_hdr = ofpbuf_data(packet);
             nexthdr = ext_hdr->ip6e_nxt;
             if (!ofpbuf_try_pull(packet, (ext_hdr->ip6e_len + 2) * 4)) {
                return EINVAL;
             }
         } else if (nexthdr == IPPROTO_FRAGMENT) {
-            const struct ovs_16aligned_ip6_frag *frag_hdr = packet->data;
+            const struct ovs_16aligned_ip6_frag *frag_hdr = ofpbuf_data(packet);
 
             nexthdr = frag_hdr->ip6f_nxt;
             if (!ofpbuf_try_pull(packet, sizeof *frag_hdr)) {
@@ -235,8 +235,8 @@ parse_ipv6(struct ofpbuf *packet, struct flow *flow)
 static void
 parse_tcp(struct ofpbuf *b, struct flow *flow)
 {
-    if (b->size >= TCP_HEADER_LEN) {
-        const struct tcp_header *tcp = b->data;
+    if (ofpbuf_size(b) >= TCP_HEADER_LEN) {
+        const struct tcp_header *tcp = ofpbuf_data(b);
 
         flow->tp_src = tcp->tcp_src;
         flow->tp_dst = tcp->tcp_dst;
@@ -247,8 +247,8 @@ parse_tcp(struct ofpbuf *b, struct flow *flow)
 static void
 parse_udp(struct ofpbuf *b, struct flow *flow)
 {
-    if (b->size >= UDP_HEADER_LEN) {
-        const struct udp_header *udp = b->data;
+    if (ofpbuf_size(b) >= UDP_HEADER_LEN) {
+        const struct udp_header *udp = ofpbuf_data(b);
 
         flow->tp_src = udp->udp_src;
         flow->tp_dst = udp->udp_dst;
@@ -258,8 +258,8 @@ parse_udp(struct ofpbuf *b, struct flow *flow)
 static void
 parse_sctp(struct ofpbuf *b, struct flow *flow)
 {
-    if (b->size >= SCTP_HEADER_LEN) {
-        const struct sctp_header *sctp = b->data;
+    if (ofpbuf_size(b) >= SCTP_HEADER_LEN) {
+        const struct sctp_header *sctp = ofpbuf_data(b);
 
         flow->tp_src = sctp->sctp_src;
         flow->tp_dst = sctp->sctp_dst;
@@ -291,13 +291,13 @@ parse_icmpv6(struct ofpbuf *b, struct flow *flow)
         }
         flow->nd_target = *nd_target;
 
-        while (b->size >= 8) {
+        while (ofpbuf_size(b) >= 8) {
             /* The minimum size of an option is 8 bytes, which also is
              * the size of Ethernet link-layer options. */
-            const struct nd_opt_hdr *nd_opt = b->data;
+            const struct nd_opt_hdr *nd_opt = ofpbuf_data(b);
             int opt_len = nd_opt->nd_opt_len * 8;
 
-            if (!opt_len || opt_len > b->size) {
+            if (!opt_len || opt_len > ofpbuf_size(b)) {
                 goto invalid;
             }
 
@@ -371,17 +371,17 @@ flow_extract(struct ofpbuf *packet, const struct pkt_metadata *md,
         flow->pkt_mark = md->pkt_mark;
     }
 
-    packet->l2   = b.data;
+    packet->l2   = ofpbuf_data(&b);
     ofpbuf_set_l2_5(packet, NULL);
     ofpbuf_set_l3(packet, NULL);
     ofpbuf_set_l4(packet, NULL);
 
-    if (b.size < sizeof *eth) {
+    if (ofpbuf_size(&b) < sizeof *eth) {
         return;
     }
 
     /* Link layer. */
-    eth = b.data;
+    eth = ofpbuf_data(&b);
     memcpy(flow->dl_src, eth->eth_src, ETH_ADDR_LEN);
     memcpy(flow->dl_dst, eth->eth_dst, ETH_ADDR_LEN);
 
@@ -394,16 +394,16 @@ flow_extract(struct ofpbuf *packet, const struct pkt_metadata *md,
 
     /* Parse mpls, copy l3 ttl. */
     if (eth_type_mpls(flow->dl_type)) {
-        ofpbuf_set_l2_5(packet, b.data);
+        ofpbuf_set_l2_5(packet, ofpbuf_data(&b));
         parse_mpls(&b, flow);
     }
 
     /* Network layer. */
-    ofpbuf_set_l3(packet, b.data);
+    ofpbuf_set_l3(packet, ofpbuf_data(&b));
     if (flow->dl_type == htons(ETH_TYPE_IP)) {
         const struct ip_header *nh = pull_ip(&b);
         if (nh) {
-            ofpbuf_set_l4(packet, b.data);
+            ofpbuf_set_l4(packet, ofpbuf_data(&b));
 
             flow->nw_src = get_16aligned_be32(&nh->ip_src);
             flow->nw_dst = get_16aligned_be32(&nh->ip_dst);
@@ -439,7 +439,7 @@ flow_extract(struct ofpbuf *packet, const struct pkt_metadata *md,
             return;
         }
 
-        ofpbuf_set_l4(packet, b.data);
+        ofpbuf_set_l4(packet, ofpbuf_data(&b));
         if (flow->nw_proto == IPPROTO_TCP) {
             parse_tcp(&b, flow);
         } else if (flow->nw_proto == IPPROTO_UDP) {
@@ -1331,7 +1331,7 @@ flow_compose(struct ofpbuf *b, const struct flow *flow)
     eth_compose(b, flow->dl_dst, flow->dl_src, ntohs(flow->dl_type), 0);
     if (flow->dl_type == htons(FLOW_DL_TYPE_NONE)) {
         struct eth_header *eth = b->l2;
-        eth->eth_type = htons(b->size);
+        eth->eth_type = htons(ofpbuf_size(b));
         return;
     }
 
diff --git a/lib/jsonrpc.c b/lib/jsonrpc.c
index 643a3c5d0..bda0f7fbf 100644
--- a/lib/jsonrpc.c
+++ b/lib/jsonrpc.c
@@ -119,11 +119,11 @@ jsonrpc_run(struct jsonrpc *rpc)
         struct ofpbuf *buf = ofpbuf_from_list(rpc->output.next);
         int retval;
 
-        retval = stream_send(rpc->stream, buf->data, buf->size);
+        retval = stream_send(rpc->stream, ofpbuf_data(buf), ofpbuf_size(buf));
         if (retval >= 0) {
             rpc->backlog -= retval;
             ofpbuf_pull(buf, retval);
-            if (!buf->size) {
+            if (!ofpbuf_size(buf)) {
                 list_remove(&buf->list_node);
                 ofpbuf_delete(buf);
             }
@@ -256,7 +256,7 @@ jsonrpc_send(struct jsonrpc *rpc, struct jsonrpc_msg *msg)
 
     buf = xmalloc(sizeof *buf);
     ofpbuf_use(buf, s, length);
-    buf->size = length;
+    ofpbuf_set_size(buf, length);
     list_push_back(&rpc->output, &buf->list_node);
     rpc->backlog += length;
 
diff --git a/lib/lacp.c b/lib/lacp.c
index 711d7ec12..923c10fe3 100644
--- a/lib/lacp.c
+++ b/lib/lacp.c
@@ -181,7 +181,7 @@ parse_lacp_packet(const struct ofpbuf *b)
 {
     const struct lacp_pdu *pdu;
 
-    pdu = ofpbuf_at(b, (uint8_t *)ofpbuf_get_l3(b) - (uint8_t *)b->data,
+    pdu = ofpbuf_at(b, (uint8_t *)ofpbuf_get_l3(b) - (uint8_t *)ofpbuf_data(b),
                     LACP_PDU_LEN);
 
     if (pdu && pdu->subtype == 1
diff --git a/lib/learn.c b/lib/learn.c
index 61799c9f7..27b7105bd 100644
--- a/lib/learn.c
+++ b/lib/learn.c
@@ -255,7 +255,7 @@ learn_to_nxast(const struct ofpact_learn *learn, struct ofpbuf *openflow)
     struct nx_action_learn *nal;
     size_t start_ofs;
 
-    start_ofs = openflow->size;
+    start_ofs = ofpbuf_size(openflow);
     nal = ofputil_put_NXAST_LEARN(openflow);
     nal->idle_timeout = htons(learn->idle_timeout);
     nal->hard_timeout = htons(learn->hard_timeout);
@@ -287,12 +287,12 @@ learn_to_nxast(const struct ofpact_learn *learn, struct ofpbuf *openflow)
         }
     }
 
-    if ((openflow->size - start_ofs) % 8) {
-        ofpbuf_put_zeros(openflow, 8 - (openflow->size - start_ofs) % 8);
+    if ((ofpbuf_size(openflow) - start_ofs) % 8) {
+        ofpbuf_put_zeros(openflow, 8 - (ofpbuf_size(openflow) - start_ofs) % 8);
     }
 
     nal = ofpbuf_at_assert(openflow, start_ofs, sizeof *nal);
-    nal->len = htons(openflow->size - start_ofs);
+    nal->len = htons(ofpbuf_size(openflow) - start_ofs);
 }
 
 /* Composes 'fm' so that executing it will implement 'learn' given that the
@@ -382,8 +382,8 @@ learn_execute(const struct ofpact_learn *learn, const struct flow *flow,
     }
     ofpact_pad(ofpacts);
 
-    fm->ofpacts = ofpacts->data;
-    fm->ofpacts_len = ofpacts->size;
+    fm->ofpacts = ofpbuf_data(ofpacts);
+    fm->ofpacts_len = ofpbuf_size(ofpacts);
 }
 
 /* Perform a bitwise-OR on 'wc''s fields that are relevant as sources in
diff --git a/lib/learning-switch.c b/lib/learning-switch.c
index 56209909f..c818a3213 100644
--- a/lib/learning-switch.c
+++ b/lib/learning-switch.c
@@ -315,12 +315,12 @@ lswitch_process_packet(struct lswitch *sw, const struct ofpbuf *msg)
 
     switch (type) {
     case OFPTYPE_ECHO_REQUEST:
-        process_echo_request(sw, msg->data);
+        process_echo_request(sw, ofpbuf_data(msg));
         break;
 
     case OFPTYPE_FEATURES_REPLY:
         if (sw->state == S_FEATURES_REPLY) {
-            if (!process_switch_features(sw, msg->data)) {
+            if (!process_switch_features(sw, ofpbuf_data(msg))) {
                 sw->state = S_SWITCHING;
             } else {
                 rconn_disconnect(sw->rconn);
@@ -329,7 +329,7 @@ lswitch_process_packet(struct lswitch *sw, const struct ofpbuf *msg)
         break;
 
     case OFPTYPE_PACKET_IN:
-        process_packet_in(sw, msg->data);
+        process_packet_in(sw, ofpbuf_data(msg));
         break;
 
     case OFPTYPE_FLOW_REMOVED:
@@ -400,7 +400,7 @@ lswitch_process_packet(struct lswitch *sw, const struct ofpbuf *msg)
     case OFPTYPE_TABLE_FEATURES_STATS_REPLY:
     default:
         if (VLOG_IS_DBG_ENABLED()) {
-            char *s = ofp_to_string(msg->data, msg->size, 2);
+            char *s = ofp_to_string(ofpbuf_data(msg), ofpbuf_size(msg), 2);
             VLOG_DBG_RL(&rl, "%016llx: OpenFlow packet ignored: %s",
                         sw->datapath_id, s);
             free(s);
@@ -598,15 +598,15 @@ process_packet_in(struct lswitch *sw, const struct ofp_header *oh)
     /* Prepare packet_out in case we need one. */
     po.buffer_id = pi.buffer_id;
     if (po.buffer_id == UINT32_MAX) {
-        po.packet = pkt.data;
-        po.packet_len = pkt.size;
+        po.packet = ofpbuf_data(&pkt);
+        po.packet_len = ofpbuf_size(&pkt);
     } else {
         po.packet = NULL;
         po.packet_len = 0;
     }
     po.in_port = pi.fmd.in_port;
-    po.ofpacts = ofpacts.data;
-    po.ofpacts_len = ofpacts.size;
+    po.ofpacts = ofpbuf_data(&ofpacts);
+    po.ofpacts_len = ofpbuf_size(&ofpacts);
 
     /* Send the packet, and possibly the whole flow, to the output port. */
     if (sw->max_idle >= 0 && (!sw->ml || out_port != OFPP_FLOOD)) {
@@ -624,8 +624,8 @@ process_packet_in(struct lswitch *sw, const struct ofp_header *oh)
         fm.idle_timeout = sw->max_idle;
         fm.buffer_id = pi.buffer_id;
         fm.out_port = OFPP_NONE;
-        fm.ofpacts = ofpacts.data;
-        fm.ofpacts_len = ofpacts.size;
+        fm.ofpacts = ofpbuf_data(&ofpacts);
+        fm.ofpacts_len = ofpbuf_size(&ofpacts);
         buffer = ofputil_encode_flow_mod(&fm, sw->protocol);
 
         queue_tx(sw, buffer);
diff --git a/lib/netdev-dpdk.c b/lib/netdev-dpdk.c
index f6adf87cc..6bf19c112 100644
--- a/lib/netdev-dpdk.c
+++ b/lib/netdev-dpdk.c
@@ -558,11 +558,11 @@ build_ofpbuf(struct rte_mbuf *pkt)
     b = ofpbuf_new(0);
     b->private_p = pkt;
 
-    b->data = pkt->pkt.data;
-    b->base = (char *)b->data - DP_NETDEV_HEADROOM - VLAN_ETH_HEADER_LEN;
-    b->allocated = pkt->buf_len;
+    ofpbuf_set_data(b, pkt->pkt.data);
+    ofpbuf_set_base(b, (char *)ofpbuf_data(b) - DP_NETDEV_HEADROOM - VLAN_ETH_HEADER_LEN);
+    b->allocated =  pkt->buf_len;
+    ofpbuf_set_size(b, rte_pktmbuf_data_len(pkt));
     b->source = OFPBUF_DPDK;
-    b->size = rte_pktmbuf_data_len(pkt);
 
     dp_packet_pad(b);
 
@@ -665,9 +665,9 @@ netdev_dpdk_send(struct netdev *netdev,
     struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
     int ret;
 
-    if (ofpbuf->size > dev->max_packet_len) {
+    if (ofpbuf_size(ofpbuf) > dev->max_packet_len) {
         VLOG_WARN_RL(&rl, "Too big size %d max_packet_len %d",
-                     (int)ofpbuf->size , dev->max_packet_len);
+                     (int)ofpbuf_size(ofpbuf) , dev->max_packet_len);
 
         ovs_mutex_lock(&dev->mutex);
         dev->stats.tx_dropped++;
@@ -680,15 +680,15 @@ netdev_dpdk_send(struct netdev *netdev,
     rte_prefetch0(&ofpbuf->private_p);
     if (!may_steal ||
         !ofpbuf->private_p || ofpbuf->source != OFPBUF_DPDK) {
-        dpdk_do_tx_copy(netdev, (char *) ofpbuf->data, ofpbuf->size);
+        dpdk_do_tx_copy(netdev, (char *) ofpbuf_data(ofpbuf), ofpbuf_size(ofpbuf));
     } else {
         struct rte_mbuf *pkt;
         int qid;
 
         pkt = ofpbuf->private_p;
         ofpbuf->private_p = NULL;
-        rte_pktmbuf_data_len(pkt) = ofpbuf->size;
-        rte_pktmbuf_pkt_len(pkt) = ofpbuf->size;
+        rte_pktmbuf_data_len(pkt) = ofpbuf_size(ofpbuf);
+        rte_pktmbuf_pkt_len(pkt) = ofpbuf_size(ofpbuf);
 
         qid = rte_lcore_id() % NR_QUEUE;
 
diff --git a/lib/netdev-dummy.c b/lib/netdev-dummy.c
index 784eff4cd..995e923da 100644
--- a/lib/netdev-dummy.c
+++ b/lib/netdev-dummy.c
@@ -198,11 +198,11 @@ dummy_packet_stream_run(struct netdev_dummy *dev, struct dummy_packet_stream *s)
         int retval;
 
         txbuf = ofpbuf_from_list(list_front(&s->txq));
-        retval = stream_send(s->stream, txbuf->data, txbuf->size);
+        retval = stream_send(s->stream, ofpbuf_data(txbuf), ofpbuf_size(txbuf));
 
         if (retval > 0) {
             ofpbuf_pull(txbuf, retval);
-            if (!txbuf->size) {
+            if (!ofpbuf_size(txbuf)) {
                 list_remove(&txbuf->list_node);
                 ofpbuf_delete(txbuf);
             }
@@ -212,17 +212,17 @@ dummy_packet_stream_run(struct netdev_dummy *dev, struct dummy_packet_stream *s)
     }
 
     if (!error) {
-        if (s->rxbuf.size < 2) {
-            n = 2 - s->rxbuf.size;
+        if (ofpbuf_size(&s->rxbuf) < 2) {
+            n = 2 - ofpbuf_size(&s->rxbuf);
         } else {
             uint16_t frame_len;
 
-            frame_len = ntohs(get_unaligned_be16(s->rxbuf.data));
+            frame_len = ntohs(get_unaligned_be16(ofpbuf_data(&s->rxbuf)));
             if (frame_len < ETH_HEADER_LEN) {
                 error = EPROTO;
                 n = 0;
             } else {
-                n = (2 + frame_len) - s->rxbuf.size;
+                n = (2 + frame_len) - ofpbuf_size(&s->rxbuf);
             }
         }
     }
@@ -233,8 +233,8 @@ dummy_packet_stream_run(struct netdev_dummy *dev, struct dummy_packet_stream *s)
         retval = stream_recv(s->stream, ofpbuf_tail(&s->rxbuf), n);
 
         if (retval > 0) {
-            s->rxbuf.size += retval;
-            if (retval == n && s->rxbuf.size > 2) {
+            ofpbuf_set_size(&s->rxbuf, ofpbuf_size(&s->rxbuf) + retval);
+            if (retval == n && ofpbuf_size(&s->rxbuf) > 2) {
                 ofpbuf_pull(&s->rxbuf, 2);
                 netdev_dummy_queue_packet(dev,
                                           ofpbuf_clone(&s->rxbuf));
@@ -242,7 +242,7 @@ dummy_packet_stream_run(struct netdev_dummy *dev, struct dummy_packet_stream *s)
             }
         } else if (retval != -EAGAIN) {
             error = (retval < 0 ? -retval
-                     : s->rxbuf.size ? EPROTO
+                     : ofpbuf_size(&s->rxbuf) ? EPROTO
                      : EOF);
         }
     }
@@ -776,7 +776,7 @@ netdev_dummy_rxq_recv(struct netdev_rxq *rxq_, struct ofpbuf **arr, int *c)
     }
     ovs_mutex_lock(&netdev->mutex);
     netdev->stats.rx_packets++;
-    netdev->stats.rx_bytes += packet->size;
+    netdev->stats.rx_bytes += ofpbuf_size(packet);
     ovs_mutex_unlock(&netdev->mutex);
 
     dp_packet_pad(packet);
@@ -821,8 +821,8 @@ static int
 netdev_dummy_send(struct netdev *netdev, struct ofpbuf *pkt, bool may_steal)
 {
     struct netdev_dummy *dev = netdev_dummy_cast(netdev);
-    const void *buffer = pkt->data;
-    size_t size = pkt->size;
+    const void *buffer = ofpbuf_data(pkt);
+    size_t size = ofpbuf_size(pkt);
 
     if (size < ETH_HEADER_LEN) {
         return EMSGSIZE;
@@ -1082,7 +1082,7 @@ eth_from_packet_or_flow(const char *s)
     }
 
     /* Convert odp_key to flow. */
-    fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
+    fitness = odp_flow_key_to_flow(ofpbuf_data(&odp_key), ofpbuf_size(&odp_key), &flow);
     if (fitness == ODP_FIT_ERROR) {
         ofpbuf_uninit(&odp_key);
         return NULL;
diff --git a/lib/netdev-linux.c b/lib/netdev-linux.c
index 6848850c4..f9634b6a4 100644
--- a/lib/netdev-linux.c
+++ b/lib/netdev-linux.c
@@ -919,7 +919,7 @@ netdev_linux_rxq_recv_sock(int fd, struct ofpbuf *buffer)
     ofpbuf_reserve(buffer, VLAN_HEADER_LEN);
     size = ofpbuf_tailroom(buffer);
 
-    iov.iov_base = buffer->data;
+    iov.iov_base = ofpbuf_data(buffer);
     iov.iov_len = size;
     msgh.msg_name = NULL;
     msgh.msg_namelen = 0;
@@ -939,7 +939,7 @@ netdev_linux_rxq_recv_sock(int fd, struct ofpbuf *buffer)
         return EMSGSIZE;
     }
 
-    buffer->size += retval;
+    ofpbuf_set_size(buffer, ofpbuf_size(buffer) + retval);
 
     for (cmsg = CMSG_FIRSTHDR(&msgh); cmsg; cmsg = CMSG_NXTHDR(&msgh, cmsg)) {
         const struct tpacket_auxdata *aux;
@@ -972,7 +972,7 @@ netdev_linux_rxq_recv_tap(int fd, struct ofpbuf *buffer)
     size_t size = ofpbuf_tailroom(buffer);
 
     do {
-        retval = read(fd, buffer->data, size);
+        retval = read(fd, ofpbuf_data(buffer), size);
     } while (retval < 0 && errno == EINTR);
 
     if (retval < 0) {
@@ -981,7 +981,7 @@ netdev_linux_rxq_recv_tap(int fd, struct ofpbuf *buffer)
         return EMSGSIZE;
     }
 
-    buffer->size += retval;
+    ofpbuf_set_size(buffer, ofpbuf_size(buffer) + retval);
     return 0;
 }
 
@@ -1056,8 +1056,8 @@ netdev_linux_rxq_drain(struct netdev_rxq *rxq_)
 static int
 netdev_linux_send(struct netdev *netdev_, struct ofpbuf *pkt, bool may_steal)
 {
-    const void *data = pkt->data;
-    size_t size = pkt->size;
+    const void *data = ofpbuf_data(pkt);
+    size_t size = ofpbuf_size(pkt);
 
     for (;;) {
         ssize_t retval;
diff --git a/lib/netlink-socket.c b/lib/netlink-socket.c
index 8c8d16be7..e4cc4ad62 100644
--- a/lib/netlink-socket.c
+++ b/lib/netlink-socket.c
@@ -250,15 +250,15 @@ nl_sock_send__(struct nl_sock *sock, const struct ofpbuf *msg,
     struct nlmsghdr *nlmsg = nl_msg_nlmsghdr(msg);
     int error;
 
-    nlmsg->nlmsg_len = msg->size;
+    nlmsg->nlmsg_len = ofpbuf_size(msg);
     nlmsg->nlmsg_seq = nlmsg_seq;
     nlmsg->nlmsg_pid = sock->pid;
     do {
         int retval;
-        retval = send(sock->fd, msg->data, msg->size, wait ? 0 : MSG_DONTWAIT);
+        retval = send(sock->fd, ofpbuf_data(msg), ofpbuf_size(msg), wait ? 0 : MSG_DONTWAIT);
         error = retval < 0 ? errno : 0;
     } while (error == EINTR);
-    log_nlmsg(__func__, error, msg->data, msg->size, sock->protocol);
+    log_nlmsg(__func__, error, ofpbuf_data(msg), ofpbuf_size(msg), sock->protocol);
     if (!error) {
         COVERAGE_INC(netlink_sent);
     }
@@ -266,7 +266,7 @@ nl_sock_send__(struct nl_sock *sock, const struct ofpbuf *msg,
 }
 
 /* Tries to send 'msg', which must contain a Netlink message, to the kernel on
- * 'sock'.  nlmsg_len in 'msg' will be finalized to match msg->size, nlmsg_pid
+ * 'sock'.  nlmsg_len in 'msg' will be finalized to match ofpbuf_size(msg), nlmsg_pid
  * will be set to 'sock''s pid, and nlmsg_seq will be initialized to a fresh
  * sequence number, before the message is sent.
  *
@@ -280,7 +280,7 @@ nl_sock_send(struct nl_sock *sock, const struct ofpbuf *msg, bool wait)
 }
 
 /* Tries to send 'msg', which must contain a Netlink message, to the kernel on
- * 'sock'.  nlmsg_len in 'msg' will be finalized to match msg->size, nlmsg_pid
+ * 'sock'.  nlmsg_len in 'msg' will be finalized to match ofpbuf_size(msg), nlmsg_pid
  * will be set to 'sock''s pid, and nlmsg_seq will be initialized to
  * 'nlmsg_seq', before the message is sent.
  *
@@ -314,7 +314,7 @@ nl_sock_recv__(struct nl_sock *sock, struct ofpbuf *buf, bool wait)
     ovs_assert(buf->allocated >= sizeof *nlmsghdr);
     ofpbuf_clear(buf);
 
-    iov[0].iov_base = buf->base;
+    iov[0].iov_base = ofpbuf_base(buf);
     iov[0].iov_len = buf->allocated;
     iov[1].iov_base = tail;
     iov[1].iov_len = sizeof tail;
@@ -343,7 +343,7 @@ nl_sock_recv__(struct nl_sock *sock, struct ofpbuf *buf, bool wait)
         return E2BIG;
     }
 
-    nlmsghdr = buf->data;
+    nlmsghdr = ofpbuf_data(buf);
     if (retval < sizeof *nlmsghdr
         || nlmsghdr->nlmsg_len < sizeof *nlmsghdr
         || nlmsghdr->nlmsg_len > retval) {
@@ -352,13 +352,13 @@ nl_sock_recv__(struct nl_sock *sock, struct ofpbuf *buf, bool wait)
         return EPROTO;
     }
 
-    buf->size = MIN(retval, buf->allocated);
+    ofpbuf_set_size(buf, MIN(retval, buf->allocated));
     if (retval > buf->allocated) {
         COVERAGE_INC(netlink_recv_jumbo);
         ofpbuf_put(buf, tail, retval - buf->allocated);
     }
 
-    log_nlmsg(__func__, 0, buf->data, buf->size, sock->protocol);
+    log_nlmsg(__func__, 0, ofpbuf_data(buf), ofpbuf_size(buf), sock->protocol);
     COVERAGE_INC(netlink_received);
 
     return 0;
@@ -424,12 +424,12 @@ nl_sock_transact_multiple__(struct nl_sock *sock,
         struct nl_transaction *txn = transactions[i];
         struct nlmsghdr *nlmsg = nl_msg_nlmsghdr(txn->request);
 
-        nlmsg->nlmsg_len = txn->request->size;
+        nlmsg->nlmsg_len = ofpbuf_size(txn->request);
         nlmsg->nlmsg_seq = base_seq + i;
         nlmsg->nlmsg_pid = sock->pid;
 
-        iovs[i].iov_base = txn->request->data;
-        iovs[i].iov_len = txn->request->size;
+        iovs[i].iov_base = ofpbuf_data(txn->request);
+        iovs[i].iov_len = ofpbuf_size(txn->request);
     }
 
     memset(&msg, 0, sizeof msg);
@@ -442,7 +442,7 @@ nl_sock_transact_multiple__(struct nl_sock *sock,
     for (i = 0; i < n; i++) {
         struct nl_transaction *txn = transactions[i];
 
-        log_nlmsg(__func__, error, txn->request->data, txn->request->size,
+        log_nlmsg(__func__, error, ofpbuf_data(txn->request), ofpbuf_size(txn->request),
                   sock->protocol);
     }
     if (!error) {
@@ -579,12 +579,12 @@ nl_sock_transact_multiple(struct nl_sock *sock,
 #else
         enum { MAX_BATCH_BYTES = 4096 - 512 };
 #endif
-        bytes = transactions[0]->request->size;
+        bytes = ofpbuf_size(transactions[0]->request);
         for (count = 1; count < n && count < max_batch_count; count++) {
-            if (bytes + transactions[count]->request->size > MAX_BATCH_BYTES) {
+            if (bytes + ofpbuf_size(transactions[count]->request) > MAX_BATCH_BYTES) {
                 break;
             }
-            bytes += transactions[count]->request->size;
+            bytes += ofpbuf_size(transactions[count]->request);
         }
 
         error = nl_sock_transact_multiple__(sock, transactions, count, &done);
@@ -609,7 +609,7 @@ nl_sock_transact_multiple(struct nl_sock *sock,
  * reply, if any, is discarded.
  *
  * Before the message is sent, nlmsg_len in 'request' will be finalized to
- * match msg->size, nlmsg_pid will be set to 'sock''s pid, and nlmsg_seq will
+ * match ofpbuf_size(msg), nlmsg_pid will be set to 'sock''s pid, and nlmsg_seq will
  * be initialized, NLM_F_ACK will be set in nlmsg_flags.
  *
  * The caller is responsible for destroying 'request'.
@@ -709,12 +709,12 @@ nl_dump_start(struct nl_dump *dump, int protocol, const struct ofpbuf *request)
  * have been initialized with nl_dump_start(), and 'buffer' must have been
  * initialized. 'buffer' should be at least NL_DUMP_BUFSIZE bytes long.
  *
- * If successful, returns true and points 'reply->data' and 'reply->size' to
+ * If successful, returns true and points 'reply->data' and 'ofpbuf_size(reply)' to
  * the message that was retrieved. The caller must not modify 'reply' (because
  * it points within 'buffer', which will be used by future calls to this
  * function).
  *
- * On failure, returns false and sets 'reply->data' to NULL and 'reply->size'
+ * On failure, returns false and sets 'reply->data' to NULL and 'ofpbuf_size(reply)'
  * to 0.  Failure might indicate an actual error or merely the end of replies.
  * An error status for the entire dump operation is provided when it is
  * completed by calling nl_dump_done().
@@ -731,11 +731,11 @@ nl_dump_next(struct nl_dump *dump, struct ofpbuf *reply, struct ofpbuf *buffer)
     struct nlmsghdr *nlmsghdr;
     int error = 0;
 
-    reply->data = NULL;
-    reply->size = 0;
+    ofpbuf_set_data(reply, NULL);
+    ofpbuf_set_size(reply, 0);
 
     /* If 'buffer' is empty, fetch another batch of nlmsgs. */
-    while (!buffer->size) {
+    while (!ofpbuf_size(buffer)) {
         unsigned int status;
         int retval, seq;
 
diff --git a/lib/netlink.c b/lib/netlink.c
index 96abe46dd..bbd6b6d41 100644
--- a/lib/netlink.c
+++ b/lib/netlink.c
@@ -67,7 +67,7 @@ nl_msg_nlmsgerr(const struct ofpbuf *msg, int *errorp)
         int code = EPROTO;
         if (!err) {
             VLOG_ERR_RL(&rl, "received invalid nlmsgerr (%"PRIu32"d bytes < %"PRIuSIZE"d)",
-                        msg->size, NLMSG_HDRLEN + sizeof *err);
+                        ofpbuf_size(msg), NLMSG_HDRLEN + sizeof *err);
         } else if (err->error <= 0 && err->error > INT_MIN) {
             code = -err->error;
         }
@@ -113,7 +113,7 @@ nl_msg_put_nlmsghdr(struct ofpbuf *msg,
 {
     struct nlmsghdr *nlmsghdr;
 
-    ovs_assert(msg->size == 0);
+    ovs_assert(ofpbuf_size(msg) == 0);
 
     nl_msg_reserve(msg, NLMSG_HDRLEN + expected_payload);
     nlmsghdr = nl_msg_put_uninit(msg, NLMSG_HDRLEN);
@@ -152,7 +152,7 @@ nl_msg_put_genlmsghdr(struct ofpbuf *msg, size_t expected_payload,
     struct genlmsghdr *genlmsghdr;
 
     nl_msg_put_nlmsghdr(msg, GENL_HDRLEN + expected_payload, family, flags);
-    ovs_assert(msg->size == NLMSG_HDRLEN);
+    ovs_assert(ofpbuf_size(msg) == NLMSG_HDRLEN);
     genlmsghdr = nl_msg_put_uninit(msg, GENL_HDRLEN);
     genlmsghdr->cmd = cmd;
     genlmsghdr->version = version;
@@ -432,7 +432,7 @@ nl_msg_push_string(struct ofpbuf *msg, uint16_t type, const char *value)
 size_t
 nl_msg_start_nested(struct ofpbuf *msg, uint16_t type)
 {
-    size_t offset = msg->size;
+    size_t offset = ofpbuf_size(msg);
     nl_msg_put_unspec(msg, type, NULL, 0);
     return offset;
 }
@@ -443,7 +443,7 @@ void
 nl_msg_end_nested(struct ofpbuf *msg, size_t offset)
 {
     struct nlattr *attr = ofpbuf_at_assert(msg, offset, sizeof *attr);
-    attr->nla_len = msg->size - offset;
+    attr->nla_len = ofpbuf_size(msg) - offset;
 }
 
 /* Appends a nested Netlink attribute of the given 'type', with the 'size'
@@ -459,25 +459,25 @@ nl_msg_put_nested(struct ofpbuf *msg,
 
 /* If 'buffer' begins with a valid "struct nlmsghdr", pulls the header and its
  * payload off 'buffer', stores header and payload in 'msg->data' and
- * 'msg->size', and returns a pointer to the header.
+ * 'ofpbuf_size(msg)', and returns a pointer to the header.
  *
  * If 'buffer' does not begin with a "struct nlmsghdr" or begins with one that
  * is invalid, returns NULL without modifying 'buffer'. */
 struct nlmsghdr *
 nl_msg_next(struct ofpbuf *buffer, struct ofpbuf *msg)
 {
-    if (buffer->size >= sizeof(struct nlmsghdr)) {
+    if (ofpbuf_size(buffer) >= sizeof(struct nlmsghdr)) {
         struct nlmsghdr *nlmsghdr = nl_msg_nlmsghdr(buffer);
         size_t len = nlmsghdr->nlmsg_len;
-        if (len >= sizeof *nlmsghdr && len <= buffer->size) {
+        if (len >= sizeof *nlmsghdr && len <= ofpbuf_size(buffer)) {
             ofpbuf_use_const(msg, nlmsghdr, len);
             ofpbuf_pull(buffer, len);
             return nlmsghdr;
         }
     }
 
-    msg->data = NULL;
-    msg->size = 0;
+    ofpbuf_set_data(msg, NULL);
+    ofpbuf_set_size(msg, 0);
     return NULL;
 }
 
@@ -728,13 +728,13 @@ nl_policy_parse(const struct ofpbuf *msg, size_t nla_offset,
 
     memset(attrs, 0, n_attrs * sizeof *attrs);
 
-    if (msg->size < nla_offset) {
+    if (ofpbuf_size(msg) < nla_offset) {
         VLOG_DBG_RL(&rl, "missing headers in nl_policy_parse");
         return false;
     }
 
     NL_ATTR_FOR_EACH (nla, left, ofpbuf_at(msg, nla_offset, 0),
-                      msg->size - nla_offset)
+                      ofpbuf_size(msg) - nla_offset)
     {
         uint16_t type = nl_attr_type(nla);
         if (type < n_attrs && policy[type].type != NL_A_NO_ATTR) {
@@ -798,7 +798,7 @@ nl_attr_find__(const struct nlattr *attrs, size_t size, uint16_t type)
 const struct nlattr *
 nl_attr_find(const struct ofpbuf *buf, size_t hdr_len, uint16_t type)
 {
-    return nl_attr_find__(ofpbuf_at(buf, hdr_len, 0), buf->size - hdr_len,
+    return nl_attr_find__(ofpbuf_at(buf, hdr_len, 0), ofpbuf_size(buf) - hdr_len,
                           type);
 }
 
diff --git a/lib/nx-match.c b/lib/nx-match.c
index cd3bf0854..ed491efa0 100644
--- a/lib/nx-match.c
+++ b/lib/nx-match.c
@@ -215,7 +215,7 @@ nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict,
         if (!p) {
             VLOG_DBG_RL(&rl, "nx_match length %u, rounded up to a "
                         "multiple of 8, is longer than space in message (max "
-                        "length %"PRIu32")", match_len, b->size);
+                        "length %"PRIu32")", match_len, ofpbuf_size(b));
             return OFPERR_OFPBMC_BAD_LEN;
         }
     }
@@ -251,11 +251,11 @@ nx_pull_match_loose(struct ofpbuf *b, unsigned int match_len,
 static enum ofperr
 oxm_pull_match__(struct ofpbuf *b, bool strict, struct match *match)
 {
-    struct ofp11_match_header *omh = b->data;
+    struct ofp11_match_header *omh = ofpbuf_data(b);
     uint8_t *p;
     uint16_t match_len;
 
-    if (b->size < sizeof *omh) {
+    if (ofpbuf_size(b) < sizeof *omh) {
         return OFPERR_OFPBMC_BAD_LEN;
     }
 
@@ -272,7 +272,7 @@ oxm_pull_match__(struct ofpbuf *b, bool strict, struct match *match)
     if (!p) {
         VLOG_DBG_RL(&rl, "oxm length %u, rounded up to a "
                     "multiple of 8, is longer than space in message (max "
-                    "length %"PRIu32")", match_len, b->size);
+                    "length %"PRIu32")", match_len, ofpbuf_size(b));
         return OFPERR_OFPBMC_BAD_LEN;
     }
 
@@ -568,7 +568,7 @@ nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match,
            ovs_be64 cookie, ovs_be64 cookie_mask)
 {
     const struct flow *flow = &match->flow;
-    const size_t start_len = b->size;
+    const size_t start_len = ofpbuf_size(b);
     int match_len;
     int i;
 
@@ -723,7 +723,7 @@ nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match,
     /* Cookie. */
     nxm_put_64m(b, NXM_NX_COOKIE, cookie, cookie_mask);
 
-    match_len = b->size - start_len;
+    match_len = ofpbuf_size(b) - start_len;
     return match_len;
 }
 
@@ -761,7 +761,7 @@ oxm_put_match(struct ofpbuf *b, const struct match *match)
 {
     int match_len;
     struct ofp11_match_header *omh;
-    size_t start_len = b->size;
+    size_t start_len = ofpbuf_size(b);
     ovs_be64 cookie = htonll(0), cookie_mask = htonll(0);
 
     ofpbuf_put_uninit(b, sizeof *omh);
@@ -833,7 +833,7 @@ nx_match_to_string(const uint8_t *p, unsigned int match_len)
 char *
 oxm_match_to_string(const struct ofpbuf *p, unsigned int match_len)
 {
-    const struct ofp11_match_header *omh = p->data;
+    const struct ofp11_match_header *omh = ofpbuf_data(p);
     uint16_t match_len_;
     struct ds s;
 
@@ -948,10 +948,10 @@ static int
 nx_match_from_string_raw(const char *s, struct ofpbuf *b)
 {
     const char *full_s = s;
-    const size_t start_len = b->size;
+    const size_t start_len = ofpbuf_size(b);
 
     if (!strcmp(s, "<any>")) {
-        /* Ensure that 'b->data' isn't actually null. */
+        /* Ensure that 'ofpbuf_data(b)' isn't actually null. */
         ofpbuf_prealloc_tailroom(b, 1);
         return 0;
     }
@@ -1000,7 +1000,7 @@ nx_match_from_string_raw(const char *s, struct ofpbuf *b)
         s++;
     }
 
-    return b->size - start_len;
+    return ofpbuf_size(b) - start_len;
 }
 
 int
@@ -1016,7 +1016,7 @@ oxm_match_from_string(const char *s, struct ofpbuf *b)
 {
     int match_len;
     struct ofp11_match_header *omh;
-    size_t start_len = b->size;
+    size_t start_len = ofpbuf_size(b);
 
     ofpbuf_put_uninit(b, sizeof *omh);
     match_len = nx_match_from_string_raw(s, b) + sizeof *omh;
@@ -1385,8 +1385,9 @@ nx_stack_pop(struct ofpbuf *stack)
 {
     union mf_subvalue *v = NULL;
 
-    if (stack->size) {
-        stack->size -= sizeof *v;
+    if (ofpbuf_size(stack)) {
+
+        ofpbuf_set_size(stack, ofpbuf_size(stack) - sizeof *v);
         v = (union mf_subvalue *) ofpbuf_tail(stack);
     }
 
diff --git a/lib/odp-util.c b/lib/odp-util.c
index 956fef11b..b58f1c02c 100644
--- a/lib/odp-util.c
+++ b/lib/odp-util.c
@@ -605,7 +605,7 @@ parse_odp_action(const char *s, const struct simap *port_names,
             ofpbuf_init(&buf, 16);
             end = ofpbuf_put_hex(&buf, &s[n], NULL);
             if (end[0] == ')' && end[1] == ')') {
-                odp_put_userspace_action(pid, buf.data, buf.size, actions);
+                odp_put_userspace_action(pid, ofpbuf_data(&buf), ofpbuf_size(&buf), actions);
                 ofpbuf_uninit(&buf);
                 return (end + 2) - s;
             }
@@ -715,7 +715,7 @@ odp_actions_from_string(const char *s, const struct simap *port_names,
         return 0;
     }
 
-    old_size = actions->size;
+    old_size = ofpbuf_size(actions);
     for (;;) {
         int retval;
 
@@ -726,7 +726,7 @@ odp_actions_from_string(const char *s, const struct simap *port_names,
 
         retval = parse_odp_action(s, port_names, actions);
         if (retval < 0 || !strchr(delimiters, s[retval])) {
-            actions->size = old_size;
+            ofpbuf_set_size(actions, old_size);
             return -retval;
         }
         s += retval;
@@ -1442,7 +1442,7 @@ generate_all_wildcard_mask(struct ofpbuf *ofp, const struct nlattr *key)
         nl_msg_end_nested(ofp, nested_mask);
     }
 
-    return ofp->base;
+    return ofpbuf_base(ofp);
 }
 
 /* Appends to 'ds' a string representation of the 'key_len' bytes of
@@ -2430,7 +2430,7 @@ int
 odp_flow_from_string(const char *s, const struct simap *port_names,
                      struct ofpbuf *key, struct ofpbuf *mask)
 {
-    const size_t old_size = key->size;
+    const size_t old_size = ofpbuf_size(key);
     for (;;) {
         int retval;
 
@@ -2441,7 +2441,7 @@ odp_flow_from_string(const char *s, const struct simap *port_names,
 
         retval = parse_odp_key_mask_attr(s, port_names, key, mask);
         if (retval < 0) {
-            key->size = old_size;
+            ofpbuf_set_size(key, old_size);
             return -retval;
         }
         s += retval;
@@ -3448,7 +3448,7 @@ odp_put_userspace_action(uint32_t pid,
     offset = nl_msg_start_nested(odp_actions, OVS_ACTION_ATTR_USERSPACE);
     nl_msg_put_u32(odp_actions, OVS_USERSPACE_ATTR_PID, pid);
     if (userdata) {
-        userdata_ofs = odp_actions->size + NLA_HDRLEN;
+        userdata_ofs = ofpbuf_size(odp_actions) + NLA_HDRLEN;
 
         /* The OVS kernel module before OVS 1.11 and the upstream Linux kernel
          * module before Linux 3.10 required the userdata to be exactly 8 bytes
diff --git a/lib/ofp-actions.c b/lib/ofp-actions.c
index 23d89d307..a644e6eff 100644
--- a/lib/ofp-actions.c
+++ b/lib/ofp-actions.c
@@ -711,7 +711,7 @@ ofpacts_pull_openflow_actions(struct ofpbuf *openflow,
     if (actions == NULL) {
         VLOG_WARN_RL(&rl, "OpenFlow message actions length %u exceeds "
                      "remaining message length (%"PRIu32")",
-                     actions_len, openflow->size);
+                     actions_len, ofpbuf_size(openflow));
         return OFPERR_OFPBRC_BAD_LEN;
     }
 
@@ -722,7 +722,7 @@ ofpacts_pull_openflow_actions(struct ofpbuf *openflow,
         return error;
     }
 
-    error = ofpacts_verify(ofpacts->data, ofpacts->size);
+    error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts));
     if (error) {
         ofpbuf_clear(ofpacts);
     }
@@ -1420,7 +1420,7 @@ ofpacts_copy_last(struct ofpbuf *out, const struct ofpbuf *in,
     const struct ofpact *a;
 
     target = NULL;
-    OFPACT_FOR_EACH (a, in->data, in->size) {
+    OFPACT_FOR_EACH (a, ofpbuf_data(in), ofpbuf_size(in)) {
         if (a->type == filter) {
             target = a;
         }
@@ -1439,7 +1439,7 @@ ofpacts_copy_all(struct ofpbuf *out, const struct ofpbuf *in,
 {
     const struct ofpact *a;
 
-    OFPACT_FOR_EACH (a, in->data, in->size) {
+    OFPACT_FOR_EACH (a, ofpbuf_data(in), ofpbuf_size(in)) {
         if (filter(a)) {
             ofpact_copy(out, a);
         }
@@ -1497,7 +1497,7 @@ ofpacts_from_openflow11_for_action_set(const union ofp_action *in,
 {
     enum ofperr error;
     struct ofpact *a;
-    size_t start = out->size;
+    size_t start = ofpbuf_size(out);
 
     error = ofpacts_from_openflow(in, n_in, version, out);
 
@@ -1505,7 +1505,7 @@ ofpacts_from_openflow11_for_action_set(const union ofp_action *in,
         return error;
     }
 
-    OFPACT_FOR_EACH (a, ofpact_end(out->data, start), out->size - start) {
+    OFPACT_FOR_EACH (a, ofpact_end(ofpbuf_data(out), start), ofpbuf_size(out) - start) {
         if (!ofpact_is_allowed_in_actions_set(a)) {
             VLOG_WARN_RL(&rl, "disallowed action in action set");
             return OFPERR_OFPBAC_BAD_TYPE;
@@ -1769,7 +1769,7 @@ ofpacts_pull_openflow_instructions(struct ofpbuf *openflow,
     if (instructions == NULL) {
         VLOG_WARN_RL(&rl, "OpenFlow message instructions length %u exceeds "
                      "remaining message length (%"PRIu32")",
-                     instructions_len, openflow->size);
+                     instructions_len, ofpbuf_size(openflow));
         error = OFPERR_OFPBIC_BAD_LEN;
         goto exit;
     }
@@ -1814,7 +1814,7 @@ ofpacts_pull_openflow_instructions(struct ofpbuf *openflow,
         size_t start;
 
         ofpact_pad(ofpacts);
-        start = ofpacts->size;
+        start = ofpbuf_size(ofpacts);
         on = ofpact_put(ofpacts, OFPACT_WRITE_ACTIONS,
                         offsetof(struct ofpact_nest, actions));
         get_actions_from_instruction(insts[OVSINST_OFPIT11_WRITE_ACTIONS],
@@ -1825,7 +1825,7 @@ ofpacts_pull_openflow_instructions(struct ofpbuf *openflow,
             goto exit;
         }
         on = ofpbuf_at_assert(ofpacts, start, sizeof *on);
-        on->ofpact.len = ofpacts->size - start;
+        on->ofpact.len = ofpbuf_size(ofpacts) - start;
     }
     if (insts[OVSINST_OFPIT11_WRITE_METADATA]) {
         const struct ofp11_instruction_write_metadata *oiwm;
@@ -1848,7 +1848,7 @@ ofpacts_pull_openflow_instructions(struct ofpbuf *openflow,
         ogt->table_id = oigt->table_id;
     }
 
-    error = ofpacts_verify(ofpacts->data, ofpacts->size);
+    error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts));
 exit:
     if (error) {
         ofpbuf_clear(ofpacts);
@@ -2288,23 +2288,23 @@ ofpact_write_metadata_to_nxast(const struct ofpact_metadata *om,
 static void
 ofpact_note_to_nxast(const struct ofpact_note *note, struct ofpbuf *out)
 {
-    size_t start_ofs = out->size;
+    size_t start_ofs = ofpbuf_size(out);
     struct nx_action_note *nan;
     unsigned int remainder;
     unsigned int len;
 
     nan = ofputil_put_NXAST_NOTE(out);
-    out->size -= sizeof nan->note;
+    ofpbuf_set_size(out, ofpbuf_size(out) - sizeof nan->note);
 
     ofpbuf_put(out, note->data, note->length);
 
-    len = out->size - start_ofs;
+    len = ofpbuf_size(out) - start_ofs;
     remainder = len % OFP_ACTION_ALIGN;
     if (remainder) {
         ofpbuf_put_zeros(out, OFP_ACTION_ALIGN - remainder);
     }
     nan = ofpbuf_at(out, start_ofs, sizeof *nan);
-    nan->len = htons(out->size - start_ofs);
+    nan->len = htons(ofpbuf_size(out) - start_ofs);
 }
 
 static void
@@ -2981,7 +2981,7 @@ ofpacts_put_openflow_actions(const struct ofpact ofpacts[], size_t ofpacts_len,
                              enum ofp_version ofp_version)
 {
     const struct ofpact *a;
-    size_t start_size = openflow->size;
+    size_t start_size = ofpbuf_size(openflow);
 
     void (*translate)(const struct ofpact *a, struct ofpbuf *out) =
         (ofp_version == OFP10_VERSION) ? ofpact_to_openflow10 :
@@ -2991,7 +2991,7 @@ ofpacts_put_openflow_actions(const struct ofpact ofpacts[], size_t ofpacts_len,
     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
         translate(a, openflow);
     }
-    return openflow->size - start_size;
+    return ofpbuf_size(openflow) - start_size;
 }
 
 static void
@@ -3001,10 +3001,10 @@ ofpacts_update_instruction_actions(struct ofpbuf *openflow, size_t ofs)
 
     /* Update the instruction's length (or, if it's empty, delete it). */
     oia = ofpbuf_at_assert(openflow, ofs, sizeof *oia);
-    if (openflow->size > ofs + sizeof *oia) {
-        oia->len = htons(openflow->size - ofs);
+    if (ofpbuf_size(openflow) > ofs + sizeof *oia) {
+        oia->len = htons(ofpbuf_size(openflow) - ofs);
     } else {
-        openflow->size = ofs;
+        ofpbuf_set_size(openflow, ofs);
     }
 }
 
@@ -3055,7 +3055,7 @@ ofpacts_put_openflow_instructions(const struct ofpact ofpacts[],
             break;
 
         case OVSINST_OFPIT11_APPLY_ACTIONS: {
-            const size_t ofs = openflow->size;
+            const size_t ofs = ofpbuf_size(openflow);
             const size_t ofpacts_len_left =
                 (uint8_t*)ofpact_end(ofpacts, ofpacts_len) - (uint8_t*)a;
             const struct ofpact *action;
@@ -3080,7 +3080,7 @@ ofpacts_put_openflow_instructions(const struct ofpact ofpacts[],
         }
 
         case OVSINST_OFPIT11_WRITE_ACTIONS: {
-            const size_t ofs = openflow->size;
+            const size_t ofs = ofpbuf_size(openflow);
             const struct ofpact_nest *on;
 
             on = ofpact_get_WRITE_ACTIONS(a);
@@ -3648,7 +3648,7 @@ ofpact_update_len(struct ofpbuf *ofpacts, struct ofpact *ofpact)
 void
 ofpact_pad(struct ofpbuf *ofpacts)
 {
-    unsigned int pad = PAD_SIZE(ofpacts->size, OFPACT_ALIGNTO);
+    unsigned int pad = PAD_SIZE(ofpbuf_size(ofpacts), OFPACT_ALIGNTO);
     if (pad) {
         ofpbuf_put_zeros(ofpacts, pad);
     }
diff --git a/lib/ofp-errors.c b/lib/ofp-errors.c
index a8c5c3164..d1e4dbf98 100644
--- a/lib/ofp-errors.c
+++ b/lib/ofp-errors.c
@@ -323,7 +323,7 @@ ofperr_decode_msg(const struct ofp_header *oh, struct ofpbuf *payload)
     /* Translate the error type and code into an ofperr. */
     error = ofperr_decode(oh->version, vendor, type, code);
     if (error && payload) {
-        ofpbuf_use_const(payload, b.data, b.size);
+        ofpbuf_use_const(payload, ofpbuf_data(&b), ofpbuf_size(&b));
     }
     return error;
 }
diff --git a/lib/ofp-msgs.c b/lib/ofp-msgs.c
index 677d359ed..fc91aaf1d 100644
--- a/lib/ofp-msgs.c
+++ b/lib/ofp-msgs.c
@@ -371,7 +371,7 @@ ofpraw_decode_assert(const struct ofp_header *oh)
 }
 
 /* Determines the OFPRAW_* type of the OpenFlow message in 'msg', which starts
- * at 'msg->data' and has length 'msg->size' bytes.  On success, returns 0 and
+ * at 'ofpbuf_data(msg)' and has length 'ofpbuf_size(msg)' bytes.  On success, returns 0 and
  * stores the type into '*rawp'.  On failure, returns an OFPERR_* error code
  * and zeros '*rawp'.
  *
@@ -382,7 +382,7 @@ ofpraw_decode_assert(const struct ofp_header *oh)
  * (including the stats headers, vendor header, and any subtype header) with
  * ofpbuf_pull().  It also sets 'msg->l2' to the start of the OpenFlow header
  * and 'msg->l3' just beyond the headers (that is, to the final value of
- * msg->data). */
+ * ofpbuf_data(msg)). */
 enum ofperr
 ofpraw_pull(enum ofpraw *rawp, struct ofpbuf *msg)
 {
@@ -399,12 +399,12 @@ ofpraw_pull(enum ofpraw *rawp, struct ofpbuf *msg)
     enum ofpraw raw;
 
     /* Set default outputs. */
-    msg->l2 = msg->data;
-    ofpbuf_set_l3(msg, msg->data);
+    msg->l2 = ofpbuf_data(msg);
+    ofpbuf_set_l3(msg, ofpbuf_data(msg));
     *rawp = 0;
 
-    len = msg->size;
-    error = ofphdrs_decode(&hdrs, msg->data, len);
+    len = ofpbuf_size(msg);
+    error = ofphdrs_decode(&hdrs, ofpbuf_data(msg), len);
     if (error) {
         return error;
     }
@@ -417,7 +417,7 @@ ofpraw_pull(enum ofpraw *rawp, struct ofpbuf *msg)
     info = raw_info_get(raw);
     instance = raw_instance_get(info, hdrs.version);
     msg->l2 = ofpbuf_pull(msg, instance->hdrs_len);
-    ofpbuf_set_l3(msg, msg->data);
+    ofpbuf_set_l3(msg, ofpbuf_data(msg));
 
     min_len = instance->hdrs_len + info->min_body;
     switch (info->extra_multiple) {
@@ -670,7 +670,7 @@ ofpraw_put__(enum ofpraw raw, uint8_t version, ovs_be32 xid,
     oh = buf->l2;
     oh->version = version;
     oh->type = hdrs->type;
-    oh->length = htons(buf->size);
+    oh->length = htons(ofpbuf_size(buf));
     oh->xid = xid;
 
     if (hdrs->type == OFPT_VENDOR) {
@@ -790,7 +790,7 @@ ofptype_decode(enum ofptype *typep, const struct ofp_header *oh)
 }
 
 /* Determines the OFPTYPE_* type of the OpenFlow message in 'msg', which starts
- * at 'msg->data' and has length 'msg->size' bytes.  On success, returns 0 and
+ * at 'ofpbuf_data(msg)' and has length 'ofpbuf_size(msg)' bytes.  On success, returns 0 and
  * stores the type into '*typep'.  On failure, returns an OFPERR_* error code
  * and zeros '*typep'.
  *
@@ -801,7 +801,7 @@ ofptype_decode(enum ofptype *typep, const struct ofp_header *oh)
  * (including the stats headers, vendor header, and any subtype header) with
  * ofpbuf_pull().  It also sets 'msg->l2' to the start of the OpenFlow header
  * and 'msg->l3' just beyond the headers (that is, to the final value of
- * msg->data). */
+ * ofpbuf_data(msg)). */
 enum ofperr
 ofptype_pull(enum ofptype *typep, struct ofpbuf *buf)
 {
@@ -824,12 +824,12 @@ ofptype_from_ofpraw(enum ofpraw raw)
 }
 
 /* Updates the 'length' field of the OpenFlow message in 'buf' to
- * 'buf->size'. */
+ * 'ofpbuf_size(buf)'. */
 void
 ofpmsg_update_length(struct ofpbuf *buf)
 {
     struct ofp_header *oh = ofpbuf_at_assert(buf, 0, sizeof *oh);
-    oh->length = htons(buf->size);
+    oh->length = htons(ofpbuf_size(buf));
 }
 
 /* Returns just past the Openflow header (including the stats headers, vendor
@@ -880,7 +880,7 @@ ofpmp_reserve(struct list *replies, size_t len)
 {
     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
 
-    if (msg->size + len <= UINT16_MAX) {
+    if (ofpbuf_size(msg) + len <= UINT16_MAX) {
         ofpbuf_prealloc_tailroom(msg, len);
         return msg;
     } else {
@@ -888,16 +888,16 @@ ofpmp_reserve(struct list *replies, size_t len)
         struct ofpbuf *next;
         struct ofphdrs hdrs;
 
-        ofphdrs_decode_assert(&hdrs, msg->data, msg->size);
+        ofphdrs_decode_assert(&hdrs, ofpbuf_data(msg), ofpbuf_size(msg));
         hdrs_len = ofphdrs_len(&hdrs);
 
         next = ofpbuf_new(MAX(1024, hdrs_len + len));
-        ofpbuf_put(next, msg->data, hdrs_len);
-        next->l2 = next->data;
+        ofpbuf_put(next, ofpbuf_data(msg), hdrs_len);
+        next->l2 = ofpbuf_data(next);
         ofpbuf_set_l3(next, ofpbuf_tail(next));
         list_push_back(replies, &next->list_node);
 
-        *ofpmp_flags__(msg->data) |= htons(OFPSF_REPLY_MORE);
+        *ofpmp_flags__(ofpbuf_data(msg)) |= htons(OFPSF_REPLY_MORE);
 
         return next;
     }
@@ -927,11 +927,11 @@ ofpmp_postappend(struct list *replies, size_t start_ofs)
     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
 
     ovs_assert(start_ofs <= UINT16_MAX);
-    if (msg->size > UINT16_MAX) {
-        size_t len = msg->size - start_ofs;
+    if (ofpbuf_size(msg) > UINT16_MAX) {
+        size_t len = ofpbuf_size(msg) - start_ofs;
         memcpy(ofpmp_append(replies, len),
-               (const uint8_t *) msg->data + start_ofs, len);
-        msg->size = start_ofs;
+               (const uint8_t *) ofpbuf_data(msg) + start_ofs, len);
+        ofpbuf_set_size(msg, start_ofs);
     }
 }
 
diff --git a/lib/ofp-parse.c b/lib/ofp-parse.c
index 5c5bb0647..e100974c0 100644
--- a/lib/ofp-parse.c
+++ b/lib/ofp-parse.c
@@ -632,7 +632,7 @@ parse_named_action(enum ofputil_action_code code,
                    char *arg, struct ofpbuf *ofpacts,
                    enum ofputil_protocol *usable_protocols)
 {
-    size_t orig_size = ofpacts->size;
+    size_t orig_size = ofpbuf_size(ofpacts);
     struct ofpact_tunnel *tunnel;
     struct ofpact_vlan_vid *vlan_vid;
     struct ofpact_vlan_pcp *vlan_pcp;
@@ -929,7 +929,7 @@ parse_named_action(enum ofputil_action_code code,
     }
 
     if (error) {
-        ofpacts->size = orig_size;
+        ofpbuf_set_size(ofpacts, orig_size);
     }
     return error;
 }
@@ -978,7 +978,7 @@ static char * WARN_UNUSED_RESULT
 str_to_ofpacts__(char *str, struct ofpbuf *ofpacts,
                  enum ofputil_protocol *usable_protocols)
 {
-    size_t orig_size = ofpacts->size;
+    size_t orig_size = ofpbuf_size(ofpacts);
     char *pos, *act, *arg;
     int n_actions;
 
@@ -988,7 +988,7 @@ str_to_ofpacts__(char *str, struct ofpbuf *ofpacts,
         char *error = str_to_ofpact__(pos, act, arg, ofpacts, n_actions,
                                       usable_protocols);
         if (error) {
-            ofpacts->size = orig_size;
+            ofpbuf_set_size(ofpacts, orig_size);
             return error;
         }
         n_actions++;
@@ -1007,7 +1007,7 @@ static char * WARN_UNUSED_RESULT
 str_to_ofpacts(char *str, struct ofpbuf *ofpacts,
                enum ofputil_protocol *usable_protocols)
 {
-    size_t orig_size = ofpacts->size;
+    size_t orig_size = ofpbuf_size(ofpacts);
     char *error_s;
     enum ofperr error;
 
@@ -1016,9 +1016,9 @@ str_to_ofpacts(char *str, struct ofpbuf *ofpacts,
         return error_s;
     }
 
-    error = ofpacts_verify(ofpacts->data, ofpacts->size);
+    error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts));
     if (error) {
-        ofpacts->size = orig_size;
+        ofpbuf_set_size(ofpacts, orig_size);
         return xstrdup("Incorrect action ordering");
     }
 
@@ -1050,16 +1050,16 @@ parse_named_instruction(enum ovs_instruction_type type,
         size_t ofs;
 
         ofpact_pad(ofpacts);
-        ofs = ofpacts->size;
+        ofs = ofpbuf_size(ofpacts);
         on = ofpact_put(ofpacts, OFPACT_WRITE_ACTIONS,
                         offsetof(struct ofpact_nest, actions));
         error_s = str_to_ofpacts__(arg, ofpacts, usable_protocols);
 
         on = ofpbuf_at_assert(ofpacts, ofs, sizeof *on);
-        on->ofpact.len = ofpacts->size - ofs;
+        on->ofpact.len = ofpbuf_size(ofpacts) - ofs;
 
         if (error_s) {
-            ofpacts->size = ofs;
+            ofpbuf_set_size(ofpacts, ofs);
         }
         break;
     }
@@ -1095,7 +1095,7 @@ parse_named_instruction(enum ovs_instruction_type type,
 
     /* If write_metadata is specified as an action AND an instruction, ofpacts
        could be invalid. */
-    error = ofpacts_verify(ofpacts->data, ofpacts->size);
+    error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts));
     if (error) {
         return xstrdup("Incorrect instruction ordering");
     }
@@ -1110,7 +1110,7 @@ static char * WARN_UNUSED_RESULT
 str_to_inst_ofpacts(char *str, struct ofpbuf *ofpacts,
                     enum ofputil_protocol *usable_protocols)
 {
-    size_t orig_size = ofpacts->size;
+    size_t orig_size = ofpbuf_size(ofpacts);
     char *pos, *inst, *arg;
     int type;
     const char *prev_inst = NULL;
@@ -1124,7 +1124,7 @@ str_to_inst_ofpacts(char *str, struct ofpbuf *ofpacts,
             char *error = str_to_ofpact__(pos, inst, arg, ofpacts, n_actions,
                                           usable_protocols);
             if (error) {
-                ofpacts->size = orig_size;
+                ofpbuf_set_size(ofpacts, orig_size);
                 return error;
             }
 
@@ -1134,20 +1134,20 @@ str_to_inst_ofpacts(char *str, struct ofpbuf *ofpacts,
                 continue;
             }
         } else if (type == OVSINST_OFPIT11_APPLY_ACTIONS) {
-            ofpacts->size = orig_size;
+            ofpbuf_set_size(ofpacts, orig_size);
             return xasprintf("%s isn't supported. Just write actions then "
                              "it is interpreted as apply_actions", inst);
         } else {
             char *error = parse_named_instruction(type, arg, ofpacts,
                                                   usable_protocols);
             if (error) {
-                ofpacts->size = orig_size;
+                ofpbuf_set_size(ofpacts, orig_size);
                 return error;
             }
         }
 
         if (type <= prev_type) {
-            ofpacts->size = orig_size;
+            ofpbuf_set_size(ofpacts, orig_size);
             if (type == prev_type) {
                 return xasprintf("instruction %s may be specified only once",
                                  inst);
@@ -1433,7 +1433,7 @@ parse_ofp_str__(struct ofputil_flow_mod *fm, int command, char *string,
         if (!error) {
             enum ofperr err;
 
-            err = ofpacts_check(ofpacts.data, ofpacts.size, &fm->match.flow,
+            err = ofpacts_check(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &fm->match.flow,
                                 OFPP_MAX, fm->table_id, 255, usable_protocols);
             if (!err && !usable_protocols) {
                 err = OFPERR_OFPBAC_MATCH_INCONSISTENT;
@@ -1449,7 +1449,7 @@ parse_ofp_str__(struct ofputil_flow_mod *fm, int command, char *string,
             return error;
         }
 
-        fm->ofpacts_len = ofpacts.size;
+        fm->ofpacts_len = ofpbuf_size(&ofpacts);
         fm->ofpacts = ofpbuf_steal_data(&ofpacts);
     } else {
         fm->ofpacts_len = 0;
@@ -2130,8 +2130,8 @@ parse_bucket_str(struct ofputil_bucket *bucket, char *str_,
     }
 
     ofpact_pad(&ofpacts);
-    bucket->ofpacts = ofpacts.data;
-    bucket->ofpacts_len = ofpacts.size;
+    bucket->ofpacts = ofpbuf_data(&ofpacts);
+    bucket->ofpacts_len = ofpbuf_size(&ofpacts);
 
     return NULL;
 }
diff --git a/lib/ofp-print.c b/lib/ofp-print.c
index b88d1e7de..7e0963c08 100644
--- a/lib/ofp-print.c
+++ b/lib/ofp-print.c
@@ -1361,9 +1361,9 @@ ofp_print_error_msg(struct ds *string, const struct ofp_header *oh)
     ds_put_format(string, " %s\n", ofperr_get_name(error));
 
     if (error == OFPERR_OFPHFC_INCOMPATIBLE || error == OFPERR_OFPHFC_EPERM) {
-        ds_put_printable(string, payload.data, payload.size);
+        ds_put_printable(string, ofpbuf_data(&payload), ofpbuf_size(&payload));
     } else {
-        s = ofp_to_string(payload.data, payload.size, 1);
+        s = ofp_to_string(ofpbuf_data(&payload), ofpbuf_size(&payload), 1);
         ds_put_cstr(string, s);
         free(s);
     }
@@ -1663,7 +1663,7 @@ ofp_print_ofpst_table_reply13(struct ds *string, const struct ofp_header *oh,
     ofpbuf_use_const(&b, oh, ntohs(oh->length));
     ofpraw_pull_assert(&b);
 
-    n = b.size / sizeof *ts;
+    n = ofpbuf_size(&b) / sizeof *ts;
     ds_put_format(string, " %"PRIuSIZE" tables\n", n);
     if (verbosity < 1) {
         return;
@@ -1693,7 +1693,7 @@ ofp_print_ofpst_table_reply12(struct ds *string, const struct ofp_header *oh,
     ofpbuf_use_const(&b, oh, ntohs(oh->length));
     ofpraw_pull_assert(&b);
 
-    n = b.size / sizeof *ts;
+    n = ofpbuf_size(&b) / sizeof *ts;
     ds_put_format(string, " %"PRIuSIZE" tables\n", n);
     if (verbosity < 1) {
         return;
@@ -1720,7 +1720,7 @@ ofp_print_ofpst_table_reply11(struct ds *string, const struct ofp_header *oh,
     ofpbuf_use_const(&b, oh, ntohs(oh->length));
     ofpraw_pull_assert(&b);
 
-    n = b.size / sizeof *ts;
+    n = ofpbuf_size(&b) / sizeof *ts;
     ds_put_format(string, " %"PRIuSIZE" tables\n", n);
     if (verbosity < 1) {
         return;
@@ -1760,7 +1760,7 @@ ofp_print_ofpst_table_reply10(struct ds *string, const struct ofp_header *oh,
     ofpbuf_use_const(&b, oh, ntohs(oh->length));
     ofpraw_pull_assert(&b);
 
-    n = b.size / sizeof *ts;
+    n = ofpbuf_size(&b) / sizeof *ts;
     ds_put_format(string, " %"PRIuSIZE" tables\n", n);
     if (verbosity < 1) {
         return;
diff --git a/lib/ofp-util.c b/lib/ofp-util.c
index d0002d516..2b9b5c023 100644
--- a/lib/ofp-util.c
+++ b/lib/ofp-util.c
@@ -265,10 +265,10 @@ enum ofperr
 ofputil_pull_ofp11_match(struct ofpbuf *buf, struct match *match,
                          uint16_t *padded_match_len)
 {
-    struct ofp11_match_header *omh = buf->data;
+    struct ofp11_match_header *omh = ofpbuf_data(buf);
     uint16_t match_len;
 
-    if (buf->size < sizeof *omh) {
+    if (ofpbuf_size(buf) < sizeof *omh) {
         return OFPERR_OFPBMC_BAD_LEN;
     }
 
@@ -278,7 +278,7 @@ ofputil_pull_ofp11_match(struct ofpbuf *buf, struct match *match,
     case OFPMT_STANDARD: {
         struct ofp11_match *om;
 
-        if (match_len != sizeof *om || buf->size < sizeof *om) {
+        if (match_len != sizeof *om || ofpbuf_size(buf) < sizeof *om) {
             return OFPERR_OFPBMC_BAD_LEN;
         }
         om = ofpbuf_pull(buf, sizeof *om);
@@ -1234,15 +1234,15 @@ ofputil_decode_hello(const struct ofp_header *oh, uint32_t *allowed_versions)
     ofpbuf_pull(&msg, sizeof *oh);
 
     *allowed_versions = version_bitmap_from_version(oh->version);
-    while (msg.size) {
+    while (ofpbuf_size(&msg)) {
         const struct ofp_hello_elem_header *oheh;
         unsigned int len;
 
-        if (msg.size < sizeof *oheh) {
+        if (ofpbuf_size(&msg) < sizeof *oheh) {
             return false;
         }
 
-        oheh = msg.data;
+        oheh = ofpbuf_data(&msg);
         len = ntohs(oheh->length);
         if (len < sizeof *oheh || !ofpbuf_try_pull(&msg, ROUND_UP(len, 8))) {
             return false;
@@ -1543,7 +1543,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm,
             return error;
         }
 
-        error = ofpacts_pull_openflow_instructions(&b, b.size, oh->version,
+        error = ofpacts_pull_openflow_instructions(&b, ofpbuf_size(&b), oh->version,
                                                    ofpacts);
         if (error) {
             return error;
@@ -1610,7 +1610,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm,
             ofputil_normalize_match(&fm->match);
 
             /* Now get the actions. */
-            error = ofpacts_pull_openflow_actions(&b, b.size, oh->version,
+            error = ofpacts_pull_openflow_actions(&b, ofpbuf_size(&b), oh->version,
                                                   ofpacts);
             if (error) {
                 return error;
@@ -1644,7 +1644,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm,
             if (error) {
                 return error;
             }
-            error = ofpacts_pull_openflow_actions(&b, b.size, oh->version,
+            error = ofpacts_pull_openflow_actions(&b, ofpbuf_size(&b), oh->version,
                                                   ofpacts);
             if (error) {
                 return error;
@@ -1679,8 +1679,8 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm,
         }
     }
 
-    fm->ofpacts = ofpacts->data;
-    fm->ofpacts_len = ofpacts->size;
+    fm->ofpacts = ofpbuf_data(ofpacts);
+    fm->ofpacts_len = ofpbuf_size(ofpacts);
 
     error = ofputil_decode_flow_mod_flags(raw_flags, fm->command,
                                           oh->version, &fm->flags);
@@ -1778,9 +1778,9 @@ ofputil_decode_meter_mod(const struct ofp_header *oh,
             mm->meter.flags & OFPMF13_PKTPS) {
             return OFPERR_OFPMMFC_BAD_FLAGS;
         }
-        mm->meter.bands = bands->data;
+        mm->meter.bands = ofpbuf_data(bands);
 
-        error = ofputil_pull_bands(&b, b.size, &mm->meter.n_bands, bands);
+        error = ofputil_pull_bands(&b, ofpbuf_size(&b), &mm->meter.n_bands, bands);
         if (error) {
             return error;
         }
@@ -1856,14 +1856,14 @@ ofputil_append_meter_config(struct list *replies,
                             const struct ofputil_meter_config *mc)
 {
     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
-    size_t start_ofs = msg->size;
+    size_t start_ofs = ofpbuf_size(msg);
     struct ofp13_meter_config *reply = ofpbuf_put_uninit(msg, sizeof *reply);
     reply->flags = htons(mc->flags);
     reply->meter_id = htonl(mc->meter_id);
 
     ofputil_put_bands(mc->n_bands, mc->bands, msg);
 
-    reply->length = htons(msg->size - start_ofs);
+    reply->length = htons(ofpbuf_size(msg) - start_ofs);
 
     ofpmp_postappend(replies, start_ofs);
 }
@@ -1922,7 +1922,7 @@ ofputil_decode_meter_config(struct ofpbuf *msg,
         ofpraw_pull_assert(msg);
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     }
 
@@ -1930,7 +1930,7 @@ ofputil_decode_meter_config(struct ofpbuf *msg,
     if (!omc) {
         VLOG_WARN_RL(&bad_ofmsg_rl,
                      "OFPMP_METER_CONFIG reply has %"PRIu32" leftover bytes at end",
-                     msg->size);
+                     ofpbuf_size(msg));
         return OFPERR_OFPBRC_BAD_LEN;
     }
 
@@ -1942,7 +1942,7 @@ ofputil_decode_meter_config(struct ofpbuf *msg,
     }
     mc->meter_id = ntohl(omc->meter_id);
     mc->flags = ntohs(omc->flags);
-    mc->bands = bands->data;
+    mc->bands = ofpbuf_data(bands);
 
     return 0;
 }
@@ -1998,7 +1998,7 @@ ofputil_decode_meter_stats(struct ofpbuf *msg,
         ofpraw_pull_assert(msg);
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     }
 
@@ -2006,7 +2006,7 @@ ofputil_decode_meter_stats(struct ofpbuf *msg,
     if (!oms) {
         VLOG_WARN_RL(&bad_ofmsg_rl,
                      "OFPMP_METER reply has %"PRIu32" leftover bytes at end",
-                     msg->size);
+                     ofpbuf_size(msg));
         return OFPERR_OFPBRC_BAD_LEN;
     }
 
@@ -2022,7 +2022,7 @@ ofputil_decode_meter_stats(struct ofpbuf *msg,
     ms->byte_in_count = ntohll(oms->byte_in_count);
     ms->duration_sec = ntohl(oms->duration_sec);
     ms->duration_nsec = ntohl(oms->duration_nsec);
-    ms->bands = bands->data;
+    ms->bands = ofpbuf_data(bands);
 
     return 0;
 }
@@ -2250,7 +2250,7 @@ ofputil_decode_nxst_flow_request(struct ofputil_flow_stats_request *fsr,
     if (error) {
         return error;
     }
-    if (b->size) {
+    if (ofpbuf_size(b)) {
         return OFPERR_OFPBRC_BAD_LEN;
     }
 
@@ -2306,12 +2306,12 @@ ofputil_decode_queue_get_config_request(const struct ofp_header *oh,
 
     switch ((int) raw) {
     case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
-        qgcr10 = b.data;
+        qgcr10 = ofpbuf_data(&b);
         *port = u16_to_ofp(ntohs(qgcr10->port));
         return 0;
 
     case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
-        qgcr11 = b.data;
+        qgcr11 = ofpbuf_data(&b);
         return ofputil_port_from_ofp11(qgcr11->port, port);
     }
 
@@ -2380,17 +2380,17 @@ void
 ofputil_append_queue_get_config_reply(struct ofpbuf *reply,
                                       const struct ofputil_queue_config *oqc)
 {
-    const struct ofp_header *oh = reply->data;
+    const struct ofp_header *oh = ofpbuf_data(reply);
     size_t start_ofs, len_ofs;
     ovs_be16 *len;
 
-    start_ofs = reply->size;
+    start_ofs = ofpbuf_size(reply);
     if (oh->version < OFP12_VERSION) {
         struct ofp10_packet_queue *opq10;
 
         opq10 = ofpbuf_put_zeros(reply, sizeof *opq10);
         opq10->queue_id = htonl(oqc->queue_id);
-        len_ofs = (char *) &opq10->len - (char *) reply->data;
+        len_ofs = (char *) &opq10->len - (char *) ofpbuf_data(reply);
     } else {
         struct ofp11_queue_get_config_reply *qgcr11;
         struct ofp12_packet_queue *opq12;
@@ -2402,14 +2402,14 @@ ofputil_append_queue_get_config_reply(struct ofpbuf *reply,
         opq12 = ofpbuf_put_zeros(reply, sizeof *opq12);
         opq12->port = port;
         opq12->queue_id = htonl(oqc->queue_id);
-        len_ofs = (char *) &opq12->len - (char *) reply->data;
+        len_ofs = (char *) &opq12->len - (char *) ofpbuf_data(reply);
     }
 
     put_queue_rate(reply, OFPQT_MIN_RATE, oqc->min_rate);
     put_queue_rate(reply, OFPQT_MAX_RATE, oqc->max_rate);
 
     len = ofpbuf_at(reply, len_ofs, sizeof *len);
-    *len = htons(reply->size - start_ofs);
+    *len = htons(ofpbuf_size(reply) - start_ofs);
 }
 
 /* Decodes the initial part of an OFPT_QUEUE_GET_CONFIG_REPLY from 'reply' and
@@ -2468,7 +2468,7 @@ ofputil_pull_queue_get_config_reply(struct ofpbuf *reply,
     unsigned int opq_len;
     unsigned int len;
 
-    if (!reply->size) {
+    if (!ofpbuf_size(reply)) {
         return EOF;
     }
 
@@ -2498,7 +2498,7 @@ ofputil_pull_queue_get_config_reply(struct ofpbuf *reply,
         opq_len = sizeof *opq12;
     }
 
-    if (len < opq_len || len > reply->size + opq_len || len % 8) {
+    if (len < opq_len || len > ofpbuf_size(reply) + opq_len || len % 8) {
         return OFPERR_OFPBRC_BAD_LEN;
     }
     len -= opq_len;
@@ -2511,7 +2511,7 @@ ofputil_pull_queue_get_config_reply(struct ofpbuf *reply,
 
         hdr = ofpbuf_at_assert(reply, 0, sizeof *hdr);
         prop_len = ntohs(hdr->len);
-        if (prop_len < sizeof *hdr || prop_len > reply->size || prop_len % 8) {
+        if (prop_len < sizeof *hdr || prop_len > ofpbuf_size(reply) || prop_len % 8) {
             return OFPERR_OFPBRC_BAD_LEN;
         }
 
@@ -2553,10 +2553,10 @@ ofputil_decode_flow_stats_request(struct ofputil_flow_stats_request *fsr,
     raw = ofpraw_pull_assert(&b);
     switch ((int) raw) {
     case OFPRAW_OFPST10_FLOW_REQUEST:
-        return ofputil_decode_ofpst10_flow_request(fsr, b.data, false);
+        return ofputil_decode_ofpst10_flow_request(fsr, ofpbuf_data(&b), false);
 
     case OFPRAW_OFPST10_AGGREGATE_REQUEST:
-        return ofputil_decode_ofpst10_flow_request(fsr, b.data, true);
+        return ofputil_decode_ofpst10_flow_request(fsr, ofpbuf_data(&b), true);
 
     case OFPRAW_OFPST11_FLOW_REQUEST:
         return ofputil_decode_ofpst11_flow_request(fsr, &b, false);
@@ -2688,7 +2688,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs,
     }
     oh = msg->l2;
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     } else if (raw == OFPRAW_OFPST11_FLOW_REPLY
                || raw == OFPRAW_OFPST13_FLOW_REPLY) {
@@ -2699,7 +2699,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs,
         ofs = ofpbuf_try_pull(msg, sizeof *ofs);
         if (!ofs) {
             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIu32" leftover "
-                         "bytes at end", msg->size);
+                         "bytes at end", ofpbuf_size(msg));
             return EINVAL;
         }
 
@@ -2749,7 +2749,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs,
         ofs = ofpbuf_try_pull(msg, sizeof *ofs);
         if (!ofs) {
             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIu32" leftover "
-                         "bytes at end", msg->size);
+                         "bytes at end", ofpbuf_size(msg));
             return EINVAL;
         }
 
@@ -2785,7 +2785,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs,
         nfs = ofpbuf_try_pull(msg, sizeof *nfs);
         if (!nfs) {
             VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply has %"PRIu32" leftover "
-                         "bytes at end", msg->size);
+                         "bytes at end", ofpbuf_size(msg));
             return EINVAL;
         }
 
@@ -2830,8 +2830,8 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs,
         OVS_NOT_REACHED();
     }
 
-    fs->ofpacts = ofpacts->data;
-    fs->ofpacts_len = ofpacts->size;
+    fs->ofpacts = ofpbuf_data(ofpacts);
+    fs->ofpacts_len = ofpbuf_size(ofpacts);
 
     return 0;
 }
@@ -2854,11 +2854,11 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs,
                                 struct list *replies)
 {
     struct ofpbuf *reply = ofpbuf_from_list(list_back(replies));
-    size_t start_ofs = reply->size;
+    size_t start_ofs = ofpbuf_size(reply);
     enum ofpraw raw;
-    enum ofp_version version = ((struct ofp_header *)reply->data)->version;
+    enum ofp_version version = ((struct ofp_header *)ofpbuf_data(reply))->version;
 
-    ofpraw_decode_partial(&raw, reply->data, reply->size);
+    ofpraw_decode_partial(&raw, ofpbuf_data(reply), ofpbuf_size(reply));
     if (raw == OFPRAW_OFPST11_FLOW_REPLY || raw == OFPRAW_OFPST13_FLOW_REPLY) {
         struct ofp11_flow_stats *ofs;
 
@@ -2868,7 +2868,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs,
                                           version);
 
         ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs);
-        ofs->length = htons(reply->size - start_ofs);
+        ofs->length = htons(ofpbuf_size(reply) - start_ofs);
         ofs->table_id = fs->table_id;
         ofs->pad = 0;
         ofs->duration_sec = htonl(fs->duration_sec);
@@ -2892,7 +2892,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs,
         ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply,
                                      version);
         ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs);
-        ofs->length = htons(reply->size - start_ofs);
+        ofs->length = htons(ofpbuf_size(reply) - start_ofs);
         ofs->table_id = fs->table_id;
         ofs->pad = 0;
         ofputil_match_to_ofp10_match(&fs->match, &ofs->match);
@@ -2916,7 +2916,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs,
         ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply,
                                      version);
         nfs = ofpbuf_at_assert(reply, start_ofs, sizeof *nfs);
-        nfs->length = htons(reply->size - start_ofs);
+        nfs->length = htons(ofpbuf_size(reply) - start_ofs);
         nfs->table_id = fs->table_id;
         nfs->pad = 0;
         nfs->duration_sec = htonl(fs->duration_sec);
@@ -3049,7 +3049,7 @@ ofputil_decode_flow_removed(struct ofputil_flow_removed *fr,
         if (error) {
             return error;
         }
-        if (b.size) {
+        if (ofpbuf_size(&b)) {
             return OFPERR_OFPBRC_BAD_LEN;
         }
 
@@ -3159,8 +3159,8 @@ static void
 ofputil_decode_packet_in_finish(struct ofputil_packet_in *pin,
                                 struct match *match, struct ofpbuf *b)
 {
-    pin->packet = b->data;
-    pin->packet_len = b->size;
+    pin->packet = ofpbuf_data(b);
+    pin->packet_len = ofpbuf_size(b);
 
     pin->fmd.in_port = match->flow.in_port.ofp_port;
     pin->fmd.tun_id = match->flow.tunnel.tun_id;
@@ -3221,7 +3221,7 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin,
         opi = ofpbuf_pull(&b, offsetof(struct ofp10_packet_in, data));
 
         pin->packet = opi->data;
-        pin->packet_len = b.size;
+        pin->packet_len = ofpbuf_size(&b);
 
         pin->fmd.in_port = u16_to_ofp(ntohs(opi->in_port));
         pin->reason = opi->reason;
@@ -3233,8 +3233,8 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin,
 
         opi = ofpbuf_pull(&b, sizeof *opi);
 
-        pin->packet = b.data;
-        pin->packet_len = b.size;
+        pin->packet = ofpbuf_data(&b);
+        pin->packet_len = ofpbuf_size(&b);
 
         pin->buffer_id = ntohl(opi->buffer_id);
         error = ofputil_port_from_ofp11(opi->in_port, &pin->fmd.in_port);
@@ -3559,12 +3559,12 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po,
         return OFPERR_OFPBRC_BAD_PORT;
     }
 
-    po->ofpacts = ofpacts->data;
-    po->ofpacts_len = ofpacts->size;
+    po->ofpacts = ofpbuf_data(ofpacts);
+    po->ofpacts_len = ofpbuf_size(ofpacts);
 
     if (po->buffer_id == UINT32_MAX) {
-        po->packet = b.data;
-        po->packet_len = b.size;
+        po->packet = ofpbuf_data(&b);
+        po->packet_len = ofpbuf_size(&b);
     } else {
         po->packet = NULL;
         po->packet_len = 0;
@@ -3750,7 +3750,7 @@ ofputil_put_phy_port(enum ofp_version ofp_version,
     switch (ofp_version) {
     case OFP10_VERSION: {
         struct ofp10_phy_port *opp;
-        if (b->size + sizeof *opp <= UINT16_MAX) {
+        if (ofpbuf_size(b) + sizeof *opp <= UINT16_MAX) {
             opp = ofpbuf_put_uninit(b, sizeof *opp);
             ofputil_encode_ofp10_phy_port(pp, opp);
         }
@@ -3761,7 +3761,7 @@ ofputil_put_phy_port(enum ofp_version ofp_version,
     case OFP12_VERSION:
     case OFP13_VERSION: {
         struct ofp11_port *op;
-        if (b->size + sizeof *op <= UINT16_MAX) {
+        if (ofpbuf_size(b) + sizeof *op <= UINT16_MAX) {
             op = ofpbuf_put_uninit(b, sizeof *op);
             ofputil_encode_ofp11_port(pp, op);
         }
@@ -3902,7 +3902,7 @@ ofputil_decode_switch_features(const struct ofp_header *oh,
     features->capabilities = ntohl(osf->capabilities) &
         ofputil_capabilities_mask(oh->version);
 
-    if (b->size % ofputil_get_phy_port_size(oh->version)) {
+    if (ofpbuf_size(b) % ofputil_get_phy_port_size(oh->version)) {
         return OFPERR_OFPBRC_BAD_LEN;
     }
 
@@ -3945,12 +3945,12 @@ max_ports_in_features(const struct ofp_header *oh)
 bool
 ofputil_switch_features_ports_trunc(struct ofpbuf *b)
 {
-    struct ofp_header *oh = b->data;
+    struct ofp_header *oh = ofpbuf_data(b);
 
     if (max_ports_in_features(oh)) {
         /* Remove all the ports. */
-        b->size = (sizeof(struct ofp_header)
-                   + sizeof(struct ofp_switch_features));
+        ofpbuf_set_size(b, (sizeof(struct ofp_header) +
+                            sizeof(struct ofp_switch_features)));
         ofpmsg_update_length(b);
 
         return true;
@@ -4043,7 +4043,7 @@ void
 ofputil_put_switch_features_port(const struct ofputil_phy_port *pp,
                                  struct ofpbuf *b)
 {
-    const struct ofp_header *oh = b->data;
+    const struct ofp_header *oh = ofpbuf_data(b);
 
     if (oh->version < OFP13_VERSION) {
         ofputil_put_phy_port(oh->version, pp, b);
@@ -4130,7 +4130,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh,
     raw = ofpraw_pull_assert(&b);
 
     if (raw == OFPRAW_OFPT10_PORT_MOD) {
-        const struct ofp10_port_mod *opm = b.data;
+        const struct ofp10_port_mod *opm = ofpbuf_data(&b);
 
         pm->port_no = u16_to_ofp(ntohs(opm->port_no));
         memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN);
@@ -4138,7 +4138,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh,
         pm->mask = ntohl(opm->mask) & OFPPC10_ALL;
         pm->advertise = netdev_port_features_from_ofp10(opm->advertise);
     } else if (raw == OFPRAW_OFPT11_PORT_MOD) {
-        const struct ofp11_port_mod *opm = b.data;
+        const struct ofp11_port_mod *opm = ofpbuf_data(&b);
         enum ofperr error;
 
         error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no);
@@ -4218,19 +4218,19 @@ ofputil_pull_property(struct ofpbuf *msg, struct ofpbuf *payload,
     struct ofp_prop_header *oph;
     unsigned int len;
 
-    if (msg->size < sizeof *oph) {
+    if (ofpbuf_size(msg) < sizeof *oph) {
         return OFPERR_OFPTFFC_BAD_LEN;
     }
 
-    oph = msg->data;
+    oph = ofpbuf_data(msg);
     len = ntohs(oph->len);
-    if (len < sizeof *oph || ROUND_UP(len, 8) > msg->size) {
+    if (len < sizeof *oph || ROUND_UP(len, 8) > ofpbuf_size(msg)) {
         return OFPERR_OFPTFFC_BAD_LEN;
     }
 
     *typep = ntohs(oph->type);
     if (payload) {
-        ofpbuf_use_const(payload, msg->data, len);
+        ofpbuf_use_const(payload, ofpbuf_data(msg), len);
         ofpbuf_pull(payload, sizeof *oph);
     }
     ofpbuf_pull(msg, ROUND_UP(len, 8));
@@ -4256,7 +4256,7 @@ parse_table_ids(struct ofpbuf *payload, uint32_t *ids)
     uint16_t type;
 
     *ids = 0;
-    while (payload->size > 0) {
+    while (ofpbuf_size(payload) > 0) {
         enum ofperr error = ofputil_pull_property(payload, NULL, &type);
         if (error) {
             return error;
@@ -4272,7 +4272,7 @@ static enum ofperr
 parse_instruction_ids(struct ofpbuf *payload, bool loose, uint32_t *insts)
 {
     *insts = 0;
-    while (payload->size > 0) {
+    while (ofpbuf_size(payload) > 0) {
         enum ovs_instruction_type inst;
         enum ofperr error;
         uint16_t ofpit;
@@ -4299,8 +4299,8 @@ parse_table_features_next_table(struct ofpbuf *payload,
     size_t i;
 
     memset(next_tables, 0, bitmap_n_bytes(255));
-    for (i = 0; i < payload->size; i++) {
-        uint8_t id = ((const uint8_t *) payload->data)[i];
+    for (i = 0; i < ofpbuf_size(payload); i++) {
+        uint8_t id = ((const uint8_t *) ofpbuf_data(payload))[i];
         if (id >= 255) {
             return OFPERR_OFPTFFC_BAD_ARGUMENT;
         }
@@ -4348,7 +4348,7 @@ parse_oxms(struct ofpbuf *payload, bool loose,
     uint64_t exact, masked;
 
     exact = masked = 0;
-    while (payload->size > 0) {
+    while (ofpbuf_size(payload) > 0) {
         const struct mf_field *field;
         enum ofperr error;
         bool hasmask;
@@ -4401,21 +4401,21 @@ ofputil_decode_table_features(struct ofpbuf *msg,
     unsigned int len;
 
     if (!msg->l2) {
-        msg->l2 = msg->data;
+        msg->l2 = ofpbuf_data(msg);
         ofpraw_pull_assert(msg);
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     }
 
-    if (msg->size < sizeof *otf) {
+    if (ofpbuf_size(msg) < sizeof *otf) {
         return OFPERR_OFPTFFC_BAD_LEN;
     }
 
-    otf = msg->data;
+    otf = ofpbuf_data(msg);
     len = ntohs(otf->length);
-    if (len < sizeof *otf || len % 8 || len > msg->size) {
+    if (len < sizeof *otf || len % 8 || len > ofpbuf_size(msg)) {
         return OFPERR_OFPTFFC_BAD_LEN;
     }
     ofpbuf_pull(msg, sizeof *otf);
@@ -4431,7 +4431,7 @@ ofputil_decode_table_features(struct ofpbuf *msg,
     tf->config = ntohl(otf->config);
     tf->max_entries = ntohl(otf->max_entries);
 
-    while (msg->size > 0) {
+    while (ofpbuf_size(msg) > 0) {
         struct ofpbuf payload;
         enum ofperr error;
         uint16_t type;
@@ -4564,7 +4564,7 @@ ofputil_decode_table_mod(const struct ofp_header *oh,
     raw = ofpraw_pull_assert(&b);
 
     if (raw == OFPRAW_OFPT11_TABLE_MOD) {
-        const struct ofp11_table_mod *otm = b.data;
+        const struct ofp11_table_mod *otm = ofpbuf_data(&b);
 
         pm->table_id = otm->table_id;
         pm->config = ntohl(otm->config);
@@ -4943,18 +4943,18 @@ ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq,
     uint16_t flags;
 
     if (!msg->l2) {
-        msg->l2 = msg->data;
+        msg->l2 = ofpbuf_data(msg);
         ofpraw_pull_assert(msg);
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     }
 
     nfmr = ofpbuf_try_pull(msg, sizeof *nfmr);
     if (!nfmr) {
         VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has %"PRIu32" "
-                     "leftover bytes at end", msg->size);
+                     "leftover bytes at end", ofpbuf_size(msg));
         return OFPERR_OFPBRC_BAD_LEN;
     }
 
@@ -4987,11 +4987,11 @@ ofputil_append_flow_monitor_request(
     size_t start_ofs;
     int match_len;
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         ofpraw_put(OFPRAW_NXST_FLOW_MONITOR_REQUEST, OFP10_VERSION, msg);
     }
 
-    start_ofs = msg->size;
+    start_ofs = ofpbuf_size(msg);
     ofpbuf_put_zeros(msg, sizeof *nfmr);
     match_len = nx_put_match(msg, &rq->match, htonll(0), htonll(0));
 
@@ -5028,24 +5028,24 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update,
     struct ofp_header *oh;
 
     if (!msg->l2) {
-        msg->l2 = msg->data;
+        msg->l2 = ofpbuf_data(msg);
         ofpraw_pull_assert(msg);
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     }
 
-    if (msg->size < sizeof(struct nx_flow_update_header)) {
+    if (ofpbuf_size(msg) < sizeof(struct nx_flow_update_header)) {
         goto bad_len;
     }
 
     oh = msg->l2;
 
-    nfuh = msg->data;
+    nfuh = ofpbuf_data(msg);
     update->event = ntohs(nfuh->event);
     length = ntohs(nfuh->length);
-    if (length > msg->size || length % 8) {
+    if (length > ofpbuf_size(msg) || length % 8) {
         goto bad_len;
     }
 
@@ -5096,8 +5096,8 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update,
             return error;
         }
 
-        update->ofpacts = ofpacts->data;
-        update->ofpacts_len = ofpacts->size;
+        update->ofpacts = ofpbuf_data(ofpacts);
+        update->ofpacts_len = ofpbuf_size(ofpacts);
         return 0;
     } else {
         VLOG_WARN_RL(&bad_ofmsg_rl,
@@ -5108,7 +5108,7 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update,
 
 bad_len:
     VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %"PRIu32" "
-                 "leftover bytes at end", msg->size);
+                 "leftover bytes at end", ofpbuf_size(msg));
     return OFPERR_OFPBRC_BAD_LEN;
 }
 
@@ -5154,7 +5154,7 @@ ofputil_append_flow_update(const struct ofputil_flow_update *update,
     enum ofp_version version;
 
     msg = ofpbuf_from_list(list_back(replies));
-    start_ofs = msg->size;
+    start_ofs = ofpbuf_size(msg);
     version = ((struct ofp_header *)msg->l2)->version;
 
     if (update->event == NXFME_ABBREV) {
@@ -5181,7 +5181,7 @@ ofputil_append_flow_update(const struct ofputil_flow_update *update,
     }
 
     nfuh = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuh);
-    nfuh->length = htons(msg->size - start_ofs);
+    nfuh->length = htons(ofpbuf_size(msg) - start_ofs);
     nfuh->event = htons(update->event);
 
     ofpmp_postappend(replies, start_ofs);
@@ -5207,14 +5207,14 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po,
 
         msg = ofpraw_alloc(OFPRAW_OFPT10_PACKET_OUT, OFP10_VERSION, size);
         ofpbuf_put_zeros(msg, sizeof *opo);
-        actions_ofs = msg->size;
+        actions_ofs = ofpbuf_size(msg);
         ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg,
                                      ofp_version);
 
         opo = ofpbuf_get_l3(msg);
         opo->buffer_id = htonl(po->buffer_id);
         opo->in_port = htons(ofp_to_u16(po->in_port));
-        opo->actions_len = htons(msg->size - actions_ofs);
+        opo->actions_len = htons(ofpbuf_size(msg) - actions_ofs);
         break;
     }
 
@@ -5268,8 +5268,8 @@ make_echo_reply(const struct ofp_header *rq)
     ofpbuf_use_const(&rq_buf, rq, ntohs(rq->length));
     ofpraw_pull_assert(&rq_buf);
 
-    reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY, rq, rq_buf.size);
-    ofpbuf_put(reply, rq_buf.data, rq_buf.size);
+    reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY, rq, ofpbuf_size(&rq_buf));
+    ofpbuf_put(reply, ofpbuf_data(&rq_buf), ofpbuf_size(&rq_buf));
     return reply;
 }
 
@@ -5572,7 +5572,7 @@ ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b,
  * 'ofp_version', returns the number of elements. */
 size_t ofputil_count_phy_ports(uint8_t ofp_version, struct ofpbuf *b)
 {
-    return b->size / ofputil_get_phy_port_size(ofp_version);
+    return ofpbuf_size(b) / ofputil_get_phy_port_size(ofp_version);
 }
 
 /* ofp-util.def lists the mapping from names to action. */
@@ -5982,7 +5982,7 @@ ofputil_append_port_stat(struct list *replies,
                          const struct ofputil_port_stats *ops)
 {
     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
-    struct ofp_header *oh = msg->data;
+    struct ofp_header *oh = ofpbuf_data(msg);
 
     switch ((enum ofp_version)oh->version) {
     case OFP13_VERSION: {
@@ -6107,7 +6107,7 @@ ofputil_count_port_stats(const struct ofp_header *oh)
     ofpbuf_use_const(&b, oh, ntohs(oh->length));
     ofpraw_pull_assert(&b);
 
-    return b.size / ofputil_get_port_stats_size(oh->version);
+    return ofpbuf_size(&b) / ofputil_get_port_stats_size(oh->version);
 }
 
 /* Converts an OFPST_PORT_STATS reply in 'msg' into an abstract
@@ -6133,7 +6133,7 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg)
         return error;
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     } else if (raw == OFPRAW_OFPST13_PORT_REPLY) {
         const struct ofp13_port_stats *ps13;
@@ -6165,7 +6165,7 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg)
 
  bad_len:
     VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %"PRIu32" leftover "
-                 "bytes at end", msg->size);
+                 "bytes at end", ofpbuf_size(msg));
     return OFPERR_OFPBRC_BAD_LEN;
 }
 
@@ -6321,7 +6321,7 @@ ofputil_append_group_stats(struct list *replies,
                            const struct ofputil_group_stats *ogs)
 {
     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
-    struct ofp_header *oh = msg->data;
+    struct ofp_header *oh = ofpbuf_data(msg);
 
     switch ((enum ofp_version)oh->version) {
     case OFP11_VERSION:
@@ -6458,7 +6458,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg,
         return error;
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     }
 
@@ -6484,7 +6484,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg,
 
     if (!ogs11) {
         VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIu32" leftover bytes at end",
-                     ofpraw_get_name(raw), msg->size);
+                     ofpraw_get_name(raw), ofpbuf_size(msg));
         return OFPERR_OFPBRC_BAD_LEN;
     }
     length = ntohs(ogs11->length);
@@ -6503,7 +6503,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg,
     obc = ofpbuf_try_pull(msg, gs->n_buckets * sizeof *obc);
     if (!obc) {
         VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIu32" leftover bytes at end",
-                     ofpraw_get_name(raw), msg->size);
+                     ofpraw_get_name(raw), ofpbuf_size(msg));
         return OFPERR_OFPBRC_BAD_LEN;
     }
 
@@ -6528,26 +6528,26 @@ ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds,
     struct ofp11_group_desc_stats *ogds;
     struct ofputil_bucket *bucket;
     size_t start_ogds;
-    enum ofp_version version = ((struct ofp_header *)reply->data)->version;
+    enum ofp_version version = ((struct ofp_header *)ofpbuf_data(reply))->version;
 
-    start_ogds = reply->size;
+    start_ogds = ofpbuf_size(reply);
     ofpbuf_put_zeros(reply, sizeof *ogds);
     LIST_FOR_EACH (bucket, list_node, buckets) {
         struct ofp11_bucket *ob;
         size_t start_ob;
 
-        start_ob = reply->size;
+        start_ob = ofpbuf_size(reply);
         ofpbuf_put_zeros(reply, sizeof *ob);
         ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len,
                                      reply, version);
         ob = ofpbuf_at_assert(reply, start_ob, sizeof *ob);
-        ob->len = htons(reply->size - start_ob);
+        ob->len = htons(ofpbuf_size(reply) - start_ob);
         ob->weight = htons(bucket->weight);
         ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port);
         ob->watch_group = htonl(bucket->watch_group);
     }
     ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
-    ogds->length = htons(reply->size - start_ogds);
+    ogds->length = htons(ofpbuf_size(reply) - start_ogds);
     ogds->type = gds->type;
     ogds->group_id = htonl(gds->group_id);
 
@@ -6607,7 +6607,7 @@ ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length,
         }
         bucket->watch_group = ntohl(ob->watch_group);
         bucket->ofpacts = ofpbuf_steal_data(&ofpacts);
-        bucket->ofpacts_len = ofpacts.size;
+        bucket->ofpacts_len = ofpbuf_size(&ofpacts);
         list_push_back(buckets, &bucket->list_node);
     }
 
@@ -6635,21 +6635,21 @@ ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd,
         ofpraw_pull_assert(msg);
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     }
 
     ogds = ofpbuf_try_pull(msg, sizeof *ogds);
     if (!ogds) {
         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIu32" "
-                     "leftover bytes at end", msg->size);
+                     "leftover bytes at end", ofpbuf_size(msg));
         return OFPERR_OFPBRC_BAD_LEN;
     }
     gd->type = ogds->type;
     gd->group_id = ntohl(ogds->group_id);
 
     length = ntohs(ogds->length);
-    if (length < sizeof *ogds || length - sizeof *ogds > msg->size) {
+    if (length < sizeof *ogds || length - sizeof *ogds > ofpbuf_size(msg)) {
         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid "
                      "length %"PRIuSIZE, length);
         return OFPERR_OFPBRC_BAD_LEN;
@@ -6691,11 +6691,11 @@ ofputil_encode_group_mod(enum ofp_version ofp_version,
     case OFP13_VERSION:
     case OFP14_VERSION:
         b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0);
-        start_ogm = b->size;
+        start_ogm = ofpbuf_size(b);
         ofpbuf_put_zeros(b, sizeof *ogm);
 
         LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
-            start_bucket = b->size;
+            start_bucket = ofpbuf_size(b);
             ofpbuf_put_zeros(b, sizeof *ob);
             if (bucket->ofpacts && bucket->ofpacts_len) {
                 ofpacts_put_openflow_actions(bucket->ofpacts,
@@ -6703,7 +6703,7 @@ ofputil_encode_group_mod(enum ofp_version ofp_version,
                                              ofp_version);
             }
             ob = ofpbuf_at_assert(b, start_bucket, sizeof *ob);
-            ob->len = htons(b->size - start_bucket);;
+            ob->len = htons(ofpbuf_size(b) - start_bucket);;
             ob->weight = htons(bucket->weight);
             ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port);
             ob->watch_group = htonl(bucket->watch_group);
@@ -6741,7 +6741,7 @@ ofputil_decode_group_mod(const struct ofp_header *oh,
     gm->type = ogm->type;
     gm->group_id = ntohl(ogm->group_id);
 
-    err = ofputil_pull_buckets(&msg, msg.size, oh->version, &gm->buckets);
+    err = ofputil_pull_buckets(&msg, ofpbuf_size(&msg), oh->version, &gm->buckets);
     if (err) {
         return err;
     }
@@ -6868,7 +6868,7 @@ ofputil_count_queue_stats(const struct ofp_header *oh)
     ofpbuf_use_const(&b, oh, ntohs(oh->length));
     ofpraw_pull_assert(&b);
 
-    return b.size / ofputil_get_queue_stats_size(oh->version);
+    return ofpbuf_size(&b) / ofputil_get_queue_stats_size(oh->version);
 }
 
 static enum ofperr
@@ -6941,7 +6941,7 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg)
         return error;
     }
 
-    if (!msg->size) {
+    if (!ofpbuf_size(msg)) {
         return EOF;
     } else if (raw == OFPRAW_OFPST13_QUEUE_REPLY) {
         const struct ofp13_queue_stats *qs13;
@@ -6973,7 +6973,7 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg)
 
  bad_len:
     VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIu32" leftover "
-                 "bytes at end", msg->size);
+                 "bytes at end", ofpbuf_size(msg));
     return OFPERR_OFPBRC_BAD_LEN;
 }
 
@@ -7020,7 +7020,7 @@ ofputil_append_queue_stat(struct list *replies,
                           const struct ofputil_queue_stats *oqs)
 {
     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
-    struct ofp_header *oh = msg->data;
+    struct ofp_header *oh = ofpbuf_data(msg);
 
     switch ((enum ofp_version)oh->version) {
     case OFP13_VERSION: {
diff --git a/lib/ofpbuf.c b/lib/ofpbuf.c
index 56e1ec6ca..56521b7ae 100644
--- a/lib/ofpbuf.c
+++ b/lib/ofpbuf.c
@@ -26,10 +26,12 @@ static void
 ofpbuf_use__(struct ofpbuf *b, void *base, size_t allocated,
              enum ofpbuf_source source)
 {
-    b->base = b->data = base;
+    ofpbuf_set_base(b, base);
+    ofpbuf_set_data(b, base);
+    ofpbuf_set_size(b, 0);
+
     b->allocated = allocated;
     b->source = source;
-    b->size = 0;
     b->l2 = NULL;
     b->l2_5_ofs = b->l3_ofs = b->l4_ofs = UINT16_MAX;
     list_poison(&b->list_node);
@@ -96,7 +98,7 @@ void
 ofpbuf_use_const(struct ofpbuf *b, const void *data, size_t size)
 {
     ofpbuf_use__(b, CONST_CAST(void *, data), size, OFPBUF_STACK);
-    b->size = size;
+    ofpbuf_set_size(b, size);
 }
 
 /* Initializes 'b' as an empty ofpbuf with an initial capacity of 'size'
@@ -113,7 +115,7 @@ ofpbuf_uninit(struct ofpbuf *b)
 {
     if (b) {
         if (b->source == OFPBUF_MALLOC) {
-            free(b->base);
+            free(ofpbuf_base(b));
         }
         if (b->source == OFPBUF_DPDK) {
             free_dpdk_buf(b);
@@ -150,7 +152,7 @@ ofpbuf_new_with_headroom(size_t size, size_t headroom)
 }
 
 /* Creates and returns a new ofpbuf that initially contains a copy of the
- * 'buffer->size' bytes of data starting at 'buffer->data' with no headroom or
+ * 'ofpbuf_size(buffer)' bytes of data starting at 'buffer->data' with no headroom or
  * tailroom. */
 struct ofpbuf *
 ofpbuf_clone(const struct ofpbuf *buffer)
@@ -165,10 +167,11 @@ ofpbuf_clone_with_headroom(const struct ofpbuf *buffer, size_t headroom)
 {
     struct ofpbuf *new_buffer;
 
-    new_buffer = ofpbuf_clone_data_with_headroom(buffer->data, buffer->size,
+    new_buffer = ofpbuf_clone_data_with_headroom(ofpbuf_data(buffer),
+                                                 ofpbuf_size(buffer),
                                                  headroom);
     if (buffer->l2) {
-        uintptr_t data_delta = (char *)new_buffer->data - (char *)buffer->data;
+        uintptr_t data_delta = (char *)ofpbuf_data(new_buffer) - (char *)ofpbuf_data(buffer);
 
         new_buffer->l2 = (char *) buffer->l2 + data_delta;
     }
@@ -202,7 +205,7 @@ static void
 ofpbuf_copy__(struct ofpbuf *b, uint8_t *new_base,
               size_t new_headroom, size_t new_tailroom)
 {
-    const uint8_t *old_base = b->base;
+    const uint8_t *old_base = ofpbuf_base(b);
     size_t old_headroom = ofpbuf_headroom(b);
     size_t old_tailroom = ofpbuf_tailroom(b);
     size_t copy_headroom = MIN(old_headroom, new_headroom);
@@ -210,7 +213,7 @@ ofpbuf_copy__(struct ofpbuf *b, uint8_t *new_base,
 
     memcpy(&new_base[new_headroom - copy_headroom],
            &old_base[old_headroom - copy_headroom],
-           copy_headroom + b->size + copy_tailroom);
+           copy_headroom + ofpbuf_size(b) + copy_tailroom);
 }
 
 /* Reallocates 'b' so that it has exactly 'new_headroom' and 'new_tailroom'
@@ -221,7 +224,7 @@ ofpbuf_resize__(struct ofpbuf *b, size_t new_headroom, size_t new_tailroom)
     void *new_base, *new_data;
     size_t new_allocated;
 
-    new_allocated = new_headroom + b->size + new_tailroom;
+    new_allocated = new_headroom + ofpbuf_size(b) + new_tailroom;
 
     switch (b->source) {
     case OFPBUF_DPDK:
@@ -229,11 +232,11 @@ ofpbuf_resize__(struct ofpbuf *b, size_t new_headroom, size_t new_tailroom)
 
     case OFPBUF_MALLOC:
         if (new_headroom == ofpbuf_headroom(b)) {
-            new_base = xrealloc(b->base, new_allocated);
+            new_base = xrealloc(ofpbuf_base(b), new_allocated);
         } else {
             new_base = xmalloc(new_allocated);
             ofpbuf_copy__(b, new_base, new_headroom, new_tailroom);
-            free(b->base);
+            free(ofpbuf_base(b));
         }
         break;
 
@@ -251,13 +254,13 @@ ofpbuf_resize__(struct ofpbuf *b, size_t new_headroom, size_t new_tailroom)
     }
 
     b->allocated = new_allocated;
-    b->base = new_base;
+    ofpbuf_set_base(b, new_base);
 
     new_data = (char *) new_base + new_headroom;
-    if (b->data != new_data) {
-        uintptr_t data_delta = (char *) new_data - (char *) b->data;
+    if (ofpbuf_data(b) != new_data) {
+        uintptr_t data_delta = (char *) new_data - (char *) ofpbuf_data(b);
 
-        b->data = new_data;
+        ofpbuf_set_data(b, new_data);
         if (b->l2) {
             b->l2 = (char *) b->l2 + data_delta;
         }
@@ -307,8 +310,8 @@ ofpbuf_trim(struct ofpbuf *b)
 void
 ofpbuf_padto(struct ofpbuf *b, size_t length)
 {
-    if (b->size < length) {
-        ofpbuf_put_zeros(b, length - b->size);
+    if (ofpbuf_size(b) < length) {
+        ofpbuf_put_zeros(b, length - ofpbuf_size(b));
     }
 }
 
@@ -324,9 +327,9 @@ ofpbuf_shift(struct ofpbuf *b, int delta)
                : true);
 
     if (delta != 0) {
-        char *dst = (char *) b->data + delta;
-        memmove(dst, b->data, b->size);
-        b->data = dst;
+        char *dst = (char *) ofpbuf_data(b) + delta;
+        memmove(dst, ofpbuf_data(b), ofpbuf_size(b));
+        ofpbuf_set_data(b, dst);
     }
 }
 
@@ -339,7 +342,7 @@ ofpbuf_put_uninit(struct ofpbuf *b, size_t size)
     void *p;
     ofpbuf_prealloc_tailroom(b, size);
     p = ofpbuf_tail(b);
-    b->size += size;
+    ofpbuf_set_size(b, ofpbuf_size(b) + size);
     return p;
 }
 
@@ -373,7 +376,7 @@ ofpbuf_put(struct ofpbuf *b, const void *p, size_t size)
 char *
 ofpbuf_put_hex(struct ofpbuf *b, const char *s, size_t *n)
 {
-    size_t initial_size = b->size;
+    size_t initial_size = ofpbuf_size(b);
     for (;;) {
         uint8_t byte;
         bool ok;
@@ -382,7 +385,7 @@ ofpbuf_put_hex(struct ofpbuf *b, const char *s, size_t *n)
         byte = hexits_value(s, 2, &ok);
         if (!ok) {
             if (n) {
-                *n = b->size - initial_size;
+                *n = ofpbuf_size(b) - initial_size;
             }
             return CONST_CAST(char *, s);
         }
@@ -397,9 +400,9 @@ ofpbuf_put_hex(struct ofpbuf *b, const char *s, size_t *n)
 void
 ofpbuf_reserve(struct ofpbuf *b, size_t size)
 {
-    ovs_assert(!b->size);
+    ovs_assert(!ofpbuf_size(b));
     ofpbuf_prealloc_tailroom(b, size);
-    b->data = (char*)b->data + size;
+    ofpbuf_set_data(b, (char*)ofpbuf_data(b) + size);
 }
 
 /* Reserves 'size' bytes of headroom so that they can be later allocated with
@@ -408,9 +411,9 @@ void
 ofpbuf_reserve_with_tailroom(struct ofpbuf *b, size_t headroom,
                              size_t tailroom)
 {
-    ovs_assert(!b->size);
+    ovs_assert(!ofpbuf_size(b));
     ofpbuf_prealloc_tailroom(b, headroom + tailroom);
-    b->data = (char*)b->data + headroom;
+    ofpbuf_set_data(b, (char*)ofpbuf_data(b) + headroom);
 }
 
 /* Prefixes 'size' bytes to the head end of 'b', reallocating and copying its
@@ -420,9 +423,9 @@ void *
 ofpbuf_push_uninit(struct ofpbuf *b, size_t size)
 {
     ofpbuf_prealloc_headroom(b, size);
-    b->data = (char*)b->data - size;
-    b->size += size;
-    return b->data;
+    ofpbuf_set_data(b, (char*)ofpbuf_data(b) - size);
+    ofpbuf_set_size(b, ofpbuf_size(b) + size);
+    return ofpbuf_data(b);
 }
 
 /* Prefixes 'size' zeroed bytes to the head end of 'b', reallocating and
@@ -456,15 +459,16 @@ ofpbuf_steal_data(struct ofpbuf *b)
     void *p;
     ovs_assert(b->source != OFPBUF_DPDK);
 
-    if (b->source == OFPBUF_MALLOC && b->data == b->base) {
-        p = b->data;
+    if (b->source == OFPBUF_MALLOC && ofpbuf_data(b) == ofpbuf_base(b)) {
+        p = ofpbuf_data(b);
     } else {
-        p = xmemdup(b->data, b->size);
+        p = xmemdup(ofpbuf_data(b), ofpbuf_size(b));
         if (b->source == OFPBUF_MALLOC) {
-            free(b->base);
+            free(ofpbuf_base(b));
         }
     }
-    b->base = b->data = NULL;
+    ofpbuf_set_base(b, NULL);
+    ofpbuf_set_data(b, NULL);
     return p;
 }
 
@@ -477,9 +481,9 @@ ofpbuf_to_string(const struct ofpbuf *b, size_t maxbytes)
 
     ds_init(&s);
     ds_put_format(&s, "size=%"PRIu32", allocated=%"PRIu32", head=%"PRIuSIZE", tail=%"PRIuSIZE"\n",
-                  b->size, b->allocated,
+                  ofpbuf_size(b), b->allocated,
                   ofpbuf_headroom(b), ofpbuf_tailroom(b));
-    ds_put_hex_dump(&s, b->data, MIN(b->size, maxbytes), 0, false);
+    ds_put_hex_dump(&s, ofpbuf_data(b), MIN(ofpbuf_size(b), maxbytes), 0, false);
     return ds_cstr(&s);
 }
 
@@ -516,7 +520,7 @@ ofpbuf_resize_l2_5(struct ofpbuf *b, int increment)
         ofpbuf_pull(b, -increment);
     }
 
-    b->l2 = b->data;
+    b->l2 = ofpbuf_data(b);
     /* Adjust layer offsets after l2_5. */
     ofpbuf_adjust_layer_offset(&b->l3_ofs, increment);
     ofpbuf_adjust_layer_offset(&b->l4_ofs, increment);
diff --git a/lib/ofpbuf.h b/lib/ofpbuf.h
index 9beceddd6..975438b26 100644
--- a/lib/ofpbuf.h
+++ b/lib/ofpbuf.h
@@ -58,6 +58,14 @@ struct ofpbuf {
 #endif
 };
 
+static inline void * ofpbuf_data(const struct ofpbuf *);
+static inline void ofpbuf_set_data(struct ofpbuf *, void *);
+static inline void * ofpbuf_base(const struct ofpbuf *);
+static inline void ofpbuf_set_base(struct ofpbuf *, void *);
+
+static inline uint32_t ofpbuf_size(const struct ofpbuf *);
+static inline void ofpbuf_set_size(struct ofpbuf *, uint32_t);
+
 void * ofpbuf_resize_l2(struct ofpbuf *, int increment);
 void * ofpbuf_resize_l2_5(struct ofpbuf *, int increment);
 static inline void * ofpbuf_get_l2_5(const struct ofpbuf *);
@@ -136,7 +144,7 @@ static inline bool ofpbuf_equal(const struct ofpbuf *, const struct ofpbuf *);
 static inline void *ofpbuf_get_uninit_pointer(struct ofpbuf *b)
 {
     /* XXX: If 'source' is OFPBUF_DPDK memory gets leaked! */
-    return b && b->source == OFPBUF_MALLOC ? b->base : NULL;
+    return b && b->source == OFPBUF_MALLOC ? ofpbuf_base(b) : NULL;
 }
 
 /* Frees memory that 'b' points to, as well as 'b' itself. */
@@ -153,7 +161,7 @@ static inline void ofpbuf_delete(struct ofpbuf *b)
 static inline void *ofpbuf_at(const struct ofpbuf *b, size_t offset,
                               size_t size)
 {
-    return offset + size <= b->size ? (char *) b->data + offset : NULL;
+    return offset + size <= ofpbuf_size(b) ? (char *) ofpbuf_data(b) + offset : NULL;
 }
 
 /* Returns a pointer to byte 'offset' in 'b', which must contain at least
@@ -161,21 +169,21 @@ static inline void *ofpbuf_at(const struct ofpbuf *b, size_t offset,
 static inline void *ofpbuf_at_assert(const struct ofpbuf *b, size_t offset,
                                      size_t size)
 {
-    ovs_assert(offset + size <= b->size);
-    return ((char *) b->data) + offset;
+    ovs_assert(offset + size <= ofpbuf_size(b));
+    return ((char *) ofpbuf_data(b)) + offset;
 }
 
 /* Returns the byte following the last byte of data in use in 'b'. */
 static inline void *ofpbuf_tail(const struct ofpbuf *b)
 {
-    return (char *) b->data + b->size;
+    return (char *) ofpbuf_data(b) + ofpbuf_size(b);
 }
 
 /* Returns the byte following the last byte allocated for use (but not
  * necessarily in use) by 'b'. */
 static inline void *ofpbuf_end(const struct ofpbuf *b)
 {
-    return (char *) b->base + b->allocated;
+    return (char *) ofpbuf_base(b) + b->allocated;
 }
 
 /* Returns the number of bytes of headroom in 'b', that is, the number of bytes
@@ -184,7 +192,7 @@ static inline void *ofpbuf_end(const struct ofpbuf *b)
  * headroom is 0.) */
 static inline size_t ofpbuf_headroom(const struct ofpbuf *b)
 {
-    return (char*)b->data - (char*)b->base;
+    return (char*)ofpbuf_data(b) - (char*)ofpbuf_base(b);
 }
 
 /* Returns the number of bytes that may be appended to the tail end of ofpbuf
@@ -197,18 +205,18 @@ static inline size_t ofpbuf_tailroom(const struct ofpbuf *b)
 /* Clears any data from 'b'. */
 static inline void ofpbuf_clear(struct ofpbuf *b)
 {
-    b->data = b->base;
-    b->size = 0;
+    ofpbuf_set_data(b, ofpbuf_base(b));
+    ofpbuf_set_size(b, 0);
 }
 
 /* Removes 'size' bytes from the head end of 'b', which must contain at least
  * 'size' bytes of data.  Returns the first byte of data removed. */
 static inline void *ofpbuf_pull(struct ofpbuf *b, size_t size)
 {
-    void *data = b->data;
-    ovs_assert(b->size >= size);
-    b->data = (char*)b->data + size;
-    b->size -= size;
+    void *data = ofpbuf_data(b);
+    ovs_assert(ofpbuf_size(b) >= size);
+    ofpbuf_set_data(b, (char*)ofpbuf_data(b) + size);
+    ofpbuf_set_size(b, ofpbuf_size(b) - size);
     return data;
 }
 
@@ -217,7 +225,7 @@ static inline void *ofpbuf_pull(struct ofpbuf *b, size_t size)
  * null pointer without modifying 'b'. */
 static inline void *ofpbuf_try_pull(struct ofpbuf *b, size_t size)
 {
-    return b->size >= size ? ofpbuf_pull(b, size) : NULL;
+    return ofpbuf_size(b) >= size ? ofpbuf_pull(b, size) : NULL;
 }
 
 static inline struct ofpbuf *ofpbuf_from_list(const struct list *list)
@@ -227,7 +235,8 @@ static inline struct ofpbuf *ofpbuf_from_list(const struct list *list)
 
 static inline bool ofpbuf_equal(const struct ofpbuf *a, const struct ofpbuf *b)
 {
-    return a->size == b->size && memcmp(a->data, b->data, a->size) == 0;
+    return ofpbuf_size(a) == ofpbuf_size(b) &&
+           memcmp(ofpbuf_data(a), ofpbuf_data(b), ofpbuf_size(a)) == 0;
 }
 
 static inline void * ofpbuf_get_l2_5(const struct ofpbuf *b)
@@ -299,6 +308,36 @@ static inline const void *ofpbuf_get_icmp_payload(const struct ofpbuf *b)
         ? (const char *)ofpbuf_get_l4(b) + ICMP_HEADER_LEN : NULL;
 }
 
+static inline void * ofpbuf_data(const struct ofpbuf *b)
+{
+    return b->data;
+}
+
+static inline void ofpbuf_set_data(struct ofpbuf *b, void *d)
+{
+    b->data = d;
+}
+
+static inline void * ofpbuf_base(const struct ofpbuf *b)
+{
+    return b->base;
+}
+
+static inline void ofpbuf_set_base(struct ofpbuf *b, void *d)
+{
+    b->base = d;
+}
+
+static inline uint32_t ofpbuf_size(const struct ofpbuf *b)
+{
+    return b->size;
+}
+
+static inline void ofpbuf_set_size(struct ofpbuf *b, uint32_t v)
+{
+    b->size = v;
+}
+
 #ifdef  __cplusplus
 }
 #endif
diff --git a/lib/packets.c b/lib/packets.c
index 3366089c1..d1d7e6da6 100644
--- a/lib/packets.c
+++ b/lib/packets.c
@@ -196,7 +196,7 @@ eth_pop_vlan(struct ofpbuf *packet)
 {
     struct vlan_eth_header *veh = packet->l2;
 
-    if (packet->size >= sizeof *veh
+    if (ofpbuf_size(packet) >= sizeof *veh
         && veh->veth_type == htons(ETH_TYPE_VLAN)) {
 
         memmove((char *)veh + VLAN_HEADER_LEN, veh, 2 * ETH_ADDR_LEN);
@@ -329,7 +329,7 @@ pop_mpls(struct ofpbuf *packet, ovs_be16 ethtype)
             ofpbuf_set_l2_5(packet, NULL);
         }
         /* Shift the l2 header forward. */
-        memmove((char*)packet->data + MPLS_HLEN, packet->data, len);
+        memmove((char*)ofpbuf_data(packet) + MPLS_HLEN, ofpbuf_data(packet), len);
         ofpbuf_resize_l2_5(packet, -MPLS_HLEN);
     }
 }
@@ -353,7 +353,7 @@ eth_from_hex(const char *hex, struct ofpbuf **packetp)
         return "Trailing garbage in packet data";
     }
 
-    if (packet->size < ETH_HEADER_LEN) {
+    if (ofpbuf_size(packet) < ETH_HEADER_LEN) {
         ofpbuf_delete(packet);
         *packetp = NULL;
         return "Packet data too short for Ethernet";
@@ -850,7 +850,7 @@ packet_set_sctp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
 {
     struct sctp_header *sh = ofpbuf_get_l4(packet);
     ovs_be32 old_csum, old_correct_csum, new_csum;
-    uint16_t tp_len = packet->size - ((uint8_t*)sh - (uint8_t*)packet->data);
+    uint16_t tp_len = ofpbuf_size(packet) - ((uint8_t*)sh - (uint8_t*)ofpbuf_data(packet));
 
     old_csum = sh->sctp_csum;
     sh->sctp_csum = 0;
diff --git a/lib/pcap-file.c b/lib/pcap-file.c
index a92e7d3c4..04883572b 100644
--- a/lib/pcap-file.c
+++ b/lib/pcap-file.c
@@ -198,10 +198,10 @@ ovs_pcap_write(FILE *file, struct ofpbuf *buf)
     xgettimeofday(&tv);
     prh.ts_sec = tv.tv_sec;
     prh.ts_usec = tv.tv_usec;
-    prh.incl_len = buf->size;
-    prh.orig_len = buf->size;
+    prh.incl_len = ofpbuf_size(buf);
+    prh.orig_len = ofpbuf_size(buf);
     ignore(fwrite(&prh, sizeof prh, 1, file));
-    ignore(fwrite(buf->data, buf->size, 1, file));
+    ignore(fwrite(ofpbuf_data(buf), ofpbuf_size(buf), 1, file));
 }
 
 struct tcp_key {
@@ -346,7 +346,7 @@ tcp_reader_run(struct tcp_reader *r, const struct flow *flow,
         /* Shift all of the existing payload to the very beginning of the
          * allocated space, so that we reuse allocated space instead of
          * continually expanding it. */
-        ofpbuf_shift(payload, (char *) payload->base - (char *) payload->data);
+        ofpbuf_shift(payload, (char *) ofpbuf_base(payload) - (char *) ofpbuf_data(payload));
 
         ofpbuf_put(payload, l7, l7_length);
         stream->seq_no += l7_length;
diff --git a/lib/rconn.c b/lib/rconn.c
index a5368d563..b3f467940 100644
--- a/lib/rconn.c
+++ b/lib/rconn.c
@@ -718,11 +718,11 @@ rconn_send__(struct rconn *rc, struct ofpbuf *b,
         copy_to_monitor(rc, b);
 
         if (counter) {
-            rconn_packet_counter_inc(counter, b->size);
+            rconn_packet_counter_inc(counter, ofpbuf_size(b));
         }
 
         /* Use 'l2' as a private pointer while 'b' is in txq. */
-        ovs_assert(b->l2 == b->data);
+        ovs_assert(b->l2 == ofpbuf_data(b));
         b->l2 = counter;
 
         list_push_back(&rc->txq, &b->list_node);
@@ -1107,7 +1107,7 @@ try_send(struct rconn *rc)
     OVS_REQUIRES(rc->mutex)
 {
     struct ofpbuf *msg = ofpbuf_from_list(rc->txq.next);
-    unsigned int n_bytes = msg->size;
+    unsigned int n_bytes = ofpbuf_size(msg);
     struct rconn_packet_counter *counter = msg->l2;
     int retval;
 
@@ -1115,7 +1115,7 @@ try_send(struct rconn *rc)
      * after sending, if sending is successful, because it is then owned by the
      * vconn, which might have freed it already. */
     list_remove(&msg->list_node);
-    msg->l2 = msg->data; /* Restore 'l2'. */
+    msg->l2 = ofpbuf_data(msg); /* Restore 'l2'. */
 
     retval = vconn_send(rc->vconn, msg);
     if (retval) {
@@ -1214,7 +1214,7 @@ flush_queue(struct rconn *rc)
         struct ofpbuf *b = ofpbuf_from_list(list_pop_front(&rc->txq));
         struct rconn_packet_counter *counter = b->l2;
         if (counter) {
-            rconn_packet_counter_dec(counter, b->size);
+            rconn_packet_counter_dec(counter, ofpbuf_size(b));
         }
         COVERAGE_INC(rconn_discarded);
         ofpbuf_delete(b);
@@ -1324,7 +1324,7 @@ is_admitted_msg(const struct ofpbuf *b)
     enum ofptype type;
     enum ofperr error;
 
-    error = ofptype_decode(&type, b->data);
+    error = ofptype_decode(&type, ofpbuf_data(b));
     if (error) {
         return false;
     }
diff --git a/lib/route-table.c b/lib/route-table.c
index fdc21e8cd..8f5b733ce 100644
--- a/lib/route-table.c
+++ b/lib/route-table.c
@@ -272,7 +272,7 @@ route_table_parse(struct ofpbuf *buf, struct route_table_msg *change)
         const struct rtmsg *rtm;
         const struct nlmsghdr *nlmsg;
 
-        nlmsg = buf->data;
+        nlmsg = ofpbuf_data(buf);
         rtm = ofpbuf_at(buf, NLMSG_HDRLEN, sizeof *rtm);
 
         if (rtm->rtm_family != AF_INET) {
diff --git a/lib/rtnetlink-link.c b/lib/rtnetlink-link.c
index 308338fca..1c12562c5 100644
--- a/lib/rtnetlink-link.c
+++ b/lib/rtnetlink-link.c
@@ -58,7 +58,7 @@ rtnetlink_link_parse(struct ofpbuf *buf,
         const struct nlmsghdr *nlmsg;
         const struct ifinfomsg *ifinfo;
 
-        nlmsg  = buf->data;
+        nlmsg  = ofpbuf_data(buf);
         ifinfo = ofpbuf_at(buf, NLMSG_HDRLEN, sizeof *ifinfo);
 
         change->nlmsg_type     = nlmsg->nlmsg_type;
diff --git a/lib/stp.c b/lib/stp.c
index 78dacb388..b5688241d 100644
--- a/lib/stp.c
+++ b/lib/stp.c
@@ -1542,7 +1542,7 @@ stp_send_bpdu(struct stp_port *p, const void *bpdu, size_t bpdu_size)
     /* 802.2 header. */
     memcpy(eth->eth_dst, eth_addr_stp, ETH_ADDR_LEN);
     /* p->stp->send_bpdu() must fill in source address. */
-    eth->eth_type = htons(pkt->size - ETH_HEADER_LEN);
+    eth->eth_type = htons(ofpbuf_size(pkt) - ETH_HEADER_LEN);
 
     /* LLC header. */
     llc->llc_dsap = STP_LLC_DSAP;
diff --git a/lib/stream-ssl.c b/lib/stream-ssl.c
index 14d62c429..7a0d2189a 100644
--- a/lib/stream-ssl.c
+++ b/lib/stream-ssl.c
@@ -650,14 +650,15 @@ ssl_do_tx(struct stream *stream)
 
     for (;;) {
         int old_state = SSL_get_state(sslv->ssl);
-        int ret = SSL_write(sslv->ssl, sslv->txbuf->data, sslv->txbuf->size);
+        int ret = SSL_write(sslv->ssl,
+                            ofpbuf_data(sslv->txbuf), ofpbuf_size(sslv->txbuf));
         if (old_state != SSL_get_state(sslv->ssl)) {
             sslv->rx_want = SSL_NOTHING;
         }
         sslv->tx_want = SSL_NOTHING;
         if (ret > 0) {
             ofpbuf_pull(sslv->txbuf, ret);
-            if (sslv->txbuf->size == 0) {
+            if (ofpbuf_size(sslv->txbuf) == 0) {
                 return 0;
             }
         } else {
diff --git a/lib/vconn-stream.c b/lib/vconn-stream.c
index d169840ce..9347b5ea0 100644
--- a/lib/vconn-stream.c
+++ b/lib/vconn-stream.c
@@ -103,7 +103,7 @@ vconn_stream_close(struct vconn *vconn)
     struct vconn_stream *s = vconn_stream_cast(vconn);
 
     if ((vconn->error == EPROTO || s->n_packets < 1) && s->rxbuf) {
-        stream_report_content(s->rxbuf->data, s->rxbuf->size, STREAM_OPENFLOW,
+        stream_report_content(ofpbuf_data(s->rxbuf), ofpbuf_size(s->rxbuf), STREAM_OPENFLOW,
                               THIS_MODULE, vconn_get_name(vconn));
     }
 
@@ -126,14 +126,14 @@ vconn_stream_recv__(struct vconn_stream *s, int rx_len)
     struct ofpbuf *rx = s->rxbuf;
     int want_bytes, retval;
 
-    want_bytes = rx_len - rx->size;
+    want_bytes = rx_len - ofpbuf_size(rx);
     ofpbuf_prealloc_tailroom(rx, want_bytes);
     retval = stream_recv(s->stream, ofpbuf_tail(rx), want_bytes);
     if (retval > 0) {
-        rx->size += retval;
+        ofpbuf_set_size(rx, ofpbuf_size(rx) + retval);
         return retval == want_bytes ? 0 : EAGAIN;
     } else if (retval == 0) {
-        if (rx->size) {
+        if (ofpbuf_size(rx)) {
             VLOG_ERR_RL(&rl, "connection dropped mid-packet");
             return EPROTO;
         }
@@ -156,7 +156,7 @@ vconn_stream_recv(struct vconn *vconn, struct ofpbuf **bufferp)
     }
 
     /* Read ofp_header. */
-    if (s->rxbuf->size < sizeof(struct ofp_header)) {
+    if (ofpbuf_size(s->rxbuf) < sizeof(struct ofp_header)) {
         int retval = vconn_stream_recv__(s, sizeof(struct ofp_header));
         if (retval) {
             return retval;
@@ -164,12 +164,12 @@ vconn_stream_recv(struct vconn *vconn, struct ofpbuf **bufferp)
     }
 
     /* Read payload. */
-    oh = s->rxbuf->data;
+    oh = ofpbuf_data(s->rxbuf);
     rx_len = ntohs(oh->length);
     if (rx_len < sizeof(struct ofp_header)) {
         VLOG_ERR_RL(&rl, "received too-short ofp_header (%d bytes)", rx_len);
         return EPROTO;
-    } else if (s->rxbuf->size < rx_len) {
+    } else if (ofpbuf_size(s->rxbuf) < rx_len) {
         int retval = vconn_stream_recv__(s, rx_len);
         if (retval) {
             return retval;
@@ -199,8 +199,8 @@ vconn_stream_send(struct vconn *vconn, struct ofpbuf *buffer)
         return EAGAIN;
     }
 
-    retval = stream_send(s->stream, buffer->data, buffer->size);
-    if (retval == buffer->size) {
+    retval = stream_send(s->stream, ofpbuf_data(buffer), ofpbuf_size(buffer));
+    if (retval == ofpbuf_size(buffer)) {
         ofpbuf_delete(buffer);
         return 0;
     } else if (retval >= 0 || retval == -EAGAIN) {
@@ -225,7 +225,7 @@ vconn_stream_run(struct vconn *vconn)
         return;
     }
 
-    retval = stream_send(s->stream, s->txbuf->data, s->txbuf->size);
+    retval = stream_send(s->stream, ofpbuf_data(s->txbuf), ofpbuf_size(s->txbuf));
     if (retval < 0) {
         if (retval != -EAGAIN) {
             VLOG_ERR_RL(&rl, "send: %s", ovs_strerror(-retval));
@@ -234,7 +234,7 @@ vconn_stream_run(struct vconn *vconn)
         }
     } else if (retval > 0) {
         ofpbuf_pull(s->txbuf, retval);
-        if (!s->txbuf->size) {
+        if (!ofpbuf_size(s->txbuf)) {
             vconn_stream_clear_txbuf(s);
             return;
         }
diff --git a/lib/vconn.c b/lib/vconn.c
index d6d239fb8..c24e87d26 100644
--- a/lib/vconn.c
+++ b/lib/vconn.c
@@ -456,16 +456,16 @@ vcs_recv_hello(struct vconn *vconn)
         enum ofptype type;
         enum ofperr error;
 
-        error = ofptype_decode(&type, b->data);
+        error = ofptype_decode(&type, ofpbuf_data(b));
         if (!error && type == OFPTYPE_HELLO) {
             char *peer_s, *local_s;
             uint32_t common_versions;
 
-            if (!ofputil_decode_hello(b->data, &vconn->peer_versions)) {
+            if (!ofputil_decode_hello(ofpbuf_data(b), &vconn->peer_versions)) {
                 struct ds msg = DS_EMPTY_INITIALIZER;
                 ds_put_format(&msg, "%s: unknown data in hello:\n",
                               vconn->name);
-                ds_put_hex_dump(&msg, b->data, b->size, 0, true);
+                ds_put_hex_dump(&msg, ofpbuf_data(b), ofpbuf_size(b), 0, true);
                 VLOG_WARN_RL(&bad_ofmsg_rl, "%s", ds_cstr(&msg));
                 ds_destroy(&msg);
             }
@@ -495,7 +495,7 @@ vcs_recv_hello(struct vconn *vconn)
             ofpbuf_delete(b);
             return;
         } else {
-            char *s = ofp_to_string(b->data, b->size, 1);
+            char *s = ofp_to_string(ofpbuf_data(b), ofpbuf_size(b), 1);
             VLOG_WARN_RL(&bad_ofmsg_rl,
                          "%s: received message while expecting hello: %s",
                          vconn->name, s);
@@ -598,11 +598,11 @@ vconn_recv(struct vconn *vconn, struct ofpbuf **msgp)
         retval = do_recv(vconn, &msg);
     }
     if (!retval && !vconn->recv_any_version) {
-        const struct ofp_header *oh = msg->data;
+        const struct ofp_header *oh = ofpbuf_data(msg);
         if (oh->version != vconn->version) {
             enum ofptype type;
 
-            if (ofptype_decode(&type, msg->data)
+            if (ofptype_decode(&type, ofpbuf_data(msg))
                 || (type != OFPTYPE_HELLO &&
                     type != OFPTYPE_ERROR &&
                     type != OFPTYPE_ECHO_REQUEST &&
@@ -641,7 +641,7 @@ do_recv(struct vconn *vconn, struct ofpbuf **msgp)
     if (!retval) {
         COVERAGE_INC(vconn_received);
         if (VLOG_IS_DBG_ENABLED()) {
-            char *s = ofp_to_string((*msgp)->data, (*msgp)->size, 1);
+            char *s = ofp_to_string(ofpbuf_data(*msgp), ofpbuf_size(*msgp), 1);
             VLOG_DBG_RL(&ofmsg_rl, "%s: received: %s", vconn->name, s);
             free(s);
         }
@@ -674,14 +674,14 @@ do_send(struct vconn *vconn, struct ofpbuf *msg)
 {
     int retval;
 
-    ovs_assert(msg->size >= sizeof(struct ofp_header));
+    ovs_assert(ofpbuf_size(msg) >= sizeof(struct ofp_header));
 
     ofpmsg_update_length(msg);
     if (!VLOG_IS_DBG_ENABLED()) {
         COVERAGE_INC(vconn_sent);
         retval = (vconn->class->send)(vconn, msg);
     } else {
-        char *s = ofp_to_string(msg->data, msg->size, 1);
+        char *s = ofp_to_string(ofpbuf_data(msg), ofpbuf_size(msg), 1);
         retval = (vconn->class->send)(vconn, msg);
         if (retval != EAGAIN) {
             VLOG_DBG_RL(&ofmsg_rl, "%s: sent (%s): %s",
@@ -763,7 +763,7 @@ vconn_recv_xid(struct vconn *vconn, ovs_be32 xid, struct ofpbuf **replyp)
             *replyp = NULL;
             return error;
         }
-        recv_xid = ((struct ofp_header *) reply->data)->xid;
+        recv_xid = ((struct ofp_header *) ofpbuf_data(reply))->xid;
         if (xid == recv_xid) {
             *replyp = reply;
             return 0;
@@ -790,7 +790,7 @@ int
 vconn_transact(struct vconn *vconn, struct ofpbuf *request,
                struct ofpbuf **replyp)
 {
-    ovs_be32 send_xid = ((struct ofp_header *) request->data)->xid;
+    ovs_be32 send_xid = ((struct ofp_header *) ofpbuf_data(request))->xid;
     int error;
 
     *replyp = NULL;
@@ -824,7 +824,7 @@ vconn_transact_noreply(struct vconn *vconn, struct ofpbuf *request,
     *replyp = NULL;
 
     /* Send request. */
-    request_xid = ((struct ofp_header *) request->data)->xid;
+    request_xid = ((struct ofp_header *) ofpbuf_data(request))->xid;
     error = vconn_send_block(vconn, request);
     if (error) {
         ofpbuf_delete(request);
@@ -833,7 +833,7 @@ vconn_transact_noreply(struct vconn *vconn, struct ofpbuf *request,
 
     /* Send barrier. */
     barrier = ofputil_encode_barrier_request(vconn_get_version(vconn));
-    barrier_xid = ((struct ofp_header *) barrier->data)->xid;
+    barrier_xid = ((struct ofp_header *) ofpbuf_data(barrier))->xid;
     error = vconn_send_block(vconn, barrier);
     if (error) {
         ofpbuf_delete(barrier);
@@ -852,7 +852,7 @@ vconn_transact_noreply(struct vconn *vconn, struct ofpbuf *request,
             return error;
         }
 
-        msg_xid = ((struct ofp_header *) msg->data)->xid;
+        msg_xid = ((struct ofp_header *) ofpbuf_data(msg))->xid;
         if (msg_xid == request_xid) {
             if (*replyp) {
                 VLOG_WARN_RL(&bad_ofmsg_rl, "%s: duplicate replies with "
diff --git a/ofproto/connmgr.c b/ofproto/connmgr.c
index 9bc189793..0bcb325a1 100644
--- a/ofproto/connmgr.c
+++ b/ofproto/connmgr.c
@@ -1823,7 +1823,8 @@ connmgr_flushed(struct connmgr *mgr)
         ofpact_pad(&ofpacts);
 
         match_init_catchall(&match);
-        ofproto_add_flow(mgr->ofproto, &match, 0, ofpacts.data, ofpacts.size);
+        ofproto_add_flow(mgr->ofproto, &match, 0, ofpbuf_data(&ofpacts),
+                                                  ofpbuf_size(&ofpacts));
 
         ofpbuf_uninit(&ofpacts);
     }
diff --git a/ofproto/fail-open.c b/ofproto/fail-open.c
index 467cafaf5..b29e5af2e 100644
--- a/ofproto/fail-open.c
+++ b/ofproto/fail-open.c
@@ -125,11 +125,11 @@ send_bogus_packet_ins(struct fail_open *fo)
     compose_rarp(&b, mac);
 
     memset(&pin, 0, sizeof pin);
-    pin.up.packet = b.data;
-    pin.up.packet_len = b.size;
+    pin.up.packet = ofpbuf_data(&b);
+    pin.up.packet_len = ofpbuf_size(&b);
     pin.up.reason = OFPR_NO_MATCH;
     pin.up.fmd.in_port = OFPP_LOCAL;
-    pin.send_len = b.size;
+    pin.send_len = ofpbuf_size(&b);
     pin.miss_type = OFPROTO_PACKET_IN_NO_MISS;
     connmgr_send_packet_in(fo->connmgr, &pin);
 
@@ -230,7 +230,7 @@ fail_open_flushed(struct fail_open *fo)
 
         match_init_catchall(&match);
         ofproto_add_flow(fo->ofproto, &match, FAIL_OPEN_PRIORITY,
-                         ofpacts.data, ofpacts.size);
+                         ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts));
 
         ofpbuf_uninit(&ofpacts);
     }
diff --git a/ofproto/in-band.c b/ofproto/in-band.c
index 416043e2b..42b3efbed 100644
--- a/ofproto/in-band.c
+++ b/ofproto/in-band.c
@@ -382,7 +382,7 @@ in_band_run(struct in_band *ib)
         switch (rule->op) {
         case ADD:
             ofproto_add_flow(ib->ofproto, &rule->match, rule->priority,
-                             ofpacts.data, ofpacts.size);
+                             ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts));
             break;
 
         case DEL:
diff --git a/ofproto/netflow.c b/ofproto/netflow.c
index a09374999..7729906c1 100644
--- a/ofproto/netflow.c
+++ b/ofproto/netflow.c
@@ -110,7 +110,7 @@ gen_netflow_rec(struct netflow *nf, struct netflow_flow *nf_flow,
     struct netflow_v5_header *nf_hdr;
     struct netflow_v5_record *nf_rec;
 
-    if (!nf->packet.size) {
+    if (!ofpbuf_size(&nf->packet)) {
         struct timespec now;
 
         time_wall_timespec(&now);
@@ -127,7 +127,7 @@ gen_netflow_rec(struct netflow *nf, struct netflow_flow *nf_flow,
         nf_hdr->sampling_interval = htons(0);
     }
 
-    nf_hdr = nf->packet.data;
+    nf_hdr = ofpbuf_data(&nf->packet);
     nf_hdr->count = htons(ntohs(nf_hdr->count) + 1);
 
     nf_rec = ofpbuf_put_zeros(&nf->packet, sizeof *nf_rec);
@@ -313,9 +313,9 @@ netflow_run__(struct netflow *nf) OVS_REQUIRES(mutex)
     long long int now = time_msec();
     struct netflow_flow *nf_flow, *next;
 
-    if (nf->packet.size) {
-        collectors_send(nf->collectors, nf->packet.data, nf->packet.size);
-        nf->packet.size = 0;
+    if (ofpbuf_size(&nf->packet)) {
+        collectors_send(nf->collectors, ofpbuf_data(&nf->packet), ofpbuf_size(&nf->packet));
+        ofpbuf_set_size(&nf->packet, 0);
     }
 
     if (!nf->active_timeout || now < nf->next_timeout) {
@@ -354,7 +354,7 @@ netflow_wait(struct netflow *nf) OVS_EXCLUDED(mutex)
     if (nf->active_timeout) {
         poll_timer_wait_until(nf->next_timeout);
     }
-    if (nf->packet.size) {
+    if (ofpbuf_size(&nf->packet)) {
         poll_immediate_wake();
     }
     ovs_mutex_unlock(&mutex);
diff --git a/ofproto/ofproto-dpif-ipfix.c b/ofproto/ofproto-dpif-ipfix.c
index c8fb3d7aa..08a3fca4c 100644
--- a/ofproto/ofproto-dpif-ipfix.c
+++ b/ofproto/ofproto-dpif-ipfix.c
@@ -724,11 +724,11 @@ ipfix_send_msg(const struct collectors *collectors, struct ofpbuf *msg)
     struct ipfix_header *hdr;
 
     /* Adjust the length in the header. */
-    hdr = msg->data;
-    hdr->length = htons(msg->size);
+    hdr = ofpbuf_data(msg);
+    hdr->length = htons(ofpbuf_size(msg));
 
-    collectors_send(collectors, msg->data, msg->size);
-    msg->size = 0;
+    collectors_send(collectors, ofpbuf_data(msg), ofpbuf_size(msg));
+    ofpbuf_set_size(msg, 0);
 }
 
 static uint16_t
@@ -852,7 +852,7 @@ ipfix_send_template_msg(struct dpif_ipfix_exporter *exporter,
 
     ipfix_init_header(export_time_sec, exporter->seq_number, obs_domain_id,
                       &msg);
-    set_hdr_offset = msg.size;
+    set_hdr_offset = ofpbuf_size(&msg);
 
     /* Add a Template Set. */
     set_hdr = ofpbuf_put_zeros(&msg, sizeof *set_hdr);
@@ -867,20 +867,20 @@ ipfix_send_template_msg(struct dpif_ipfix_exporter *exporter,
                     l4 != IPFIX_PROTO_L4_UNKNOWN) {
                     continue;
                 }
-                tmpl_hdr_offset = msg.size;
+                tmpl_hdr_offset = ofpbuf_size(&msg);
                 tmpl_hdr = ofpbuf_put_zeros(&msg, sizeof *tmpl_hdr);
                 tmpl_hdr->template_id = htons(
                     ipfix_get_template_id(l2, l3, l4));
                 field_count = ipfix_define_template_fields(l2, l3, l4, &msg);
                 tmpl_hdr = (struct ipfix_template_record_header*)
-                    ((uint8_t*)msg.data + tmpl_hdr_offset);
+                    ((uint8_t*)ofpbuf_data(&msg) + tmpl_hdr_offset);
                 tmpl_hdr->field_count = htons(field_count);
             }
         }
     }
 
-    set_hdr = (struct ipfix_set_header*)((uint8_t*)msg.data + set_hdr_offset);
-    set_hdr->length = htons(msg.size - set_hdr_offset);
+    set_hdr = (struct ipfix_set_header*)((uint8_t*)ofpbuf_data(&msg) + set_hdr_offset);
+    set_hdr->length = htons(ofpbuf_size(&msg) - set_hdr_offset);
 
     /* XXX: Add Options Template Sets, at least to define a Flow Keys
      * Option Template. */
@@ -1084,7 +1084,7 @@ ipfix_cache_entry_init(struct ipfix_flow_cache_entry *entry,
 
     ethernet_header_length = (l2 == IPFIX_PROTO_L2_VLAN)
         ? VLAN_ETH_HEADER_LEN : ETH_HEADER_LEN;
-    ethernet_total_length = packet->size;
+    ethernet_total_length = ofpbuf_size(packet);
 
     /* Common Ethernet entities. */
     {
@@ -1154,7 +1154,7 @@ ipfix_cache_entry_init(struct ipfix_flow_cache_entry *entry,
         data_icmp->icmp_code = ntohs(flow->tp_dst) & 0xff;
     }
 
-    flow_key->flow_key_msg_part_size = msg.size;
+    flow_key->flow_key_msg_part_size = ofpbuf_size(&msg);
 
     {
         struct timeval now;
@@ -1205,7 +1205,7 @@ ipfix_put_data_set(uint32_t export_time_sec,
     size_t set_hdr_offset;
     struct ipfix_set_header *set_hdr;
 
-    set_hdr_offset = msg->size;
+    set_hdr_offset = ofpbuf_size(msg);
 
     /* Put a Data Set. */
     set_hdr = ofpbuf_put_zeros(msg, sizeof *set_hdr);
@@ -1259,8 +1259,8 @@ ipfix_put_data_set(uint32_t export_time_sec,
             entry->maximum_ip_total_length);
     }
 
-    set_hdr = (struct ipfix_set_header*)((uint8_t*)msg->data + set_hdr_offset);
-    set_hdr->length = htons(msg->size - set_hdr_offset);
+    set_hdr = (struct ipfix_set_header*)((uint8_t*)ofpbuf_data(msg) + set_hdr_offset);
+    set_hdr->length = htons(ofpbuf_size(msg) - set_hdr_offset);
 }
 
 /* Send an IPFIX message with a single data record. */
diff --git a/ofproto/ofproto-dpif-sflow.c b/ofproto/ofproto-dpif-sflow.c
index eeff13ff3..cb1f83085 100644
--- a/ofproto/ofproto-dpif-sflow.c
+++ b/ofproto/ofproto-dpif-sflow.c
@@ -602,12 +602,12 @@ dpif_sflow_received(struct dpif_sflow *ds, struct ofpbuf *packet,
     header->header_protocol = SFLHEADER_ETHERNET_ISO8023;
     /* The frame_length should include the Ethernet FCS (4 bytes),
      * but it has already been stripped,  so we need to add 4 here. */
-    header->frame_length = packet->size + 4;
+    header->frame_length = ofpbuf_size(packet) + 4;
     /* Ethernet FCS stripped off. */
     header->stripped = 4;
-    header->header_length = MIN(packet->size,
+    header->header_length = MIN(ofpbuf_size(packet),
                                 sampler->sFlowFsMaximumHeaderSize);
-    header->header_bytes = packet->data;
+    header->header_bytes = ofpbuf_data(packet);
 
     /* Add extended switch element. */
     memset(&switchElem, 0, sizeof(switchElem));
diff --git a/ofproto/ofproto-dpif-upcall.c b/ofproto/ofproto-dpif-upcall.c
index 5b5fb6ecb..de72a227b 100644
--- a/ofproto/ofproto-dpif-upcall.c
+++ b/ofproto/ofproto-dpif-upcall.c
@@ -1043,7 +1043,7 @@ handle_upcalls(struct handler *handler, struct list *upcalls)
                 miss = existing_miss;
             }
             miss->stats.tcp_flags |= ntohs(miss->flow.tcp_flags);
-            miss->stats.n_bytes += packet->size;
+            miss->stats.n_bytes += ofpbuf_size(packet);
             miss->stats.n_packets++;
 
             upcall->flow_miss = miss;
@@ -1164,7 +1164,7 @@ handle_upcalls(struct handler *handler, struct list *upcalls)
              * the packet contained no VLAN.  So, we must remove the
              * VLAN header from the packet before trying to execute the
              * actions. */
-            if (miss->xout.odp_actions.size) {
+            if (ofpbuf_size(&miss->xout.odp_actions)) {
                 eth_pop_vlan(packet);
             }
 
@@ -1204,21 +1204,21 @@ handle_upcalls(struct handler *handler, struct list *upcalls)
             op->u.flow_put.flags = DPIF_FP_CREATE | DPIF_FP_MODIFY;
             op->u.flow_put.key = miss->key;
             op->u.flow_put.key_len = miss->key_len;
-            op->u.flow_put.mask = mask.data;
-            op->u.flow_put.mask_len = mask.size;
+            op->u.flow_put.mask = ofpbuf_data(&mask);
+            op->u.flow_put.mask_len = ofpbuf_size(&mask);
             op->u.flow_put.stats = NULL;
 
             if (!miss->xout.slow) {
-                op->u.flow_put.actions = miss->xout.odp_actions.data;
-                op->u.flow_put.actions_len = miss->xout.odp_actions.size;
+                op->u.flow_put.actions = ofpbuf_data(&miss->xout.odp_actions);
+                op->u.flow_put.actions_len = ofpbuf_size(&miss->xout.odp_actions);
             } else {
                 struct ofpbuf buf;
 
                 ofpbuf_use_stack(&buf, miss->slow_path_buf,
                                  sizeof miss->slow_path_buf);
                 compose_slow_path(udpif, &miss->xout, miss->odp_in_port, &buf);
-                op->u.flow_put.actions = buf.data;
-                op->u.flow_put.actions_len = buf.size;
+                op->u.flow_put.actions = ofpbuf_data(&buf);
+                op->u.flow_put.actions_len = ofpbuf_size(&buf);
             }
         }
 
@@ -1228,15 +1228,15 @@ handle_upcalls(struct handler *handler, struct list *upcalls)
          * upcall. */
         miss->flow.vlan_tci = flow_vlan_tci;
 
-        if (miss->xout.odp_actions.size) {
+        if (ofpbuf_size(&miss->xout.odp_actions)) {
 
             op = &ops[n_ops++];
             op->type = DPIF_OP_EXECUTE;
             op->u.execute.packet = packet;
             odp_key_to_pkt_metadata(miss->key, miss->key_len,
                                     &op->u.execute.md);
-            op->u.execute.actions = miss->xout.odp_actions.data;
-            op->u.execute.actions_len = miss->xout.odp_actions.size;
+            op->u.execute.actions = ofpbuf_data(&miss->xout.odp_actions);
+            op->u.execute.actions_len = ofpbuf_size(&miss->xout.odp_actions);
             op->u.execute.needs_help = (miss->xout.slow & SLOW_ACTION) != 0;
         }
     }
@@ -1257,8 +1257,8 @@ handle_upcalls(struct handler *handler, struct list *upcalls)
             struct ofproto_packet_in *pin;
 
             pin = xmalloc(sizeof *pin);
-            pin->up.packet = xmemdup(packet->data, packet->size);
-            pin->up.packet_len = packet->size;
+            pin->up.packet = xmemdup(ofpbuf_data(packet), ofpbuf_size(packet));
+            pin->up.packet_len = ofpbuf_size(packet);
             pin->up.reason = OFPR_NO_MATCH;
             pin->up.table_id = 0;
             pin->up.cookie = OVS_BE64_MAX;
@@ -1390,8 +1390,8 @@ revalidate_ukey(struct udpif *udpif, struct udpif_flow_dump *udump,
     }
 
     if (!xout.slow) {
-        ofpbuf_use_const(&xout_actions, xout.odp_actions.data,
-                         xout.odp_actions.size);
+        ofpbuf_use_const(&xout_actions, ofpbuf_data(&xout.odp_actions),
+                         ofpbuf_size(&xout.odp_actions));
     } else {
         ofpbuf_use_stack(&xout_actions, slow_path_buf, sizeof slow_path_buf);
         compose_slow_path(udpif, &xout, odp_in_port, &xout_actions);
diff --git a/ofproto/ofproto-dpif-xlate.c b/ofproto/ofproto-dpif-xlate.c
index e26b7c960..a6bfc8702 100644
--- a/ofproto/ofproto-dpif-xlate.c
+++ b/ofproto/ofproto-dpif-xlate.c
@@ -703,7 +703,7 @@ stp_process_packet(const struct xport *xport, const struct ofpbuf *packet)
 {
     struct stp_port *sp = xport_get_stp_port(xport);
     struct ofpbuf payload = *packet;
-    struct eth_header *eth = payload.data;
+    struct eth_header *eth = ofpbuf_data(&payload);
 
     /* Sink packets on ports that have STP disabled when the bridge has
      * STP enabled. */
@@ -712,12 +712,12 @@ stp_process_packet(const struct xport *xport, const struct ofpbuf *packet)
     }
 
     /* Trim off padding on payload. */
-    if (payload.size > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
-        payload.size = ntohs(eth->eth_type) + ETH_HEADER_LEN;
+    if (ofpbuf_size(&payload) > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
+        ofpbuf_set_size(&payload, ntohs(eth->eth_type) + ETH_HEADER_LEN);
     }
 
     if (ofpbuf_try_pull(&payload, ETH_HEADER_LEN + LLC_HEADER_LEN)) {
-        stp_received_bpdu(sp, payload.data, payload.size);
+        stp_received_bpdu(sp, ofpbuf_data(&payload), ofpbuf_size(&payload));
     }
 }
 
@@ -1742,12 +1742,12 @@ compose_output_action__(struct xlate_ctx *ctx, ofp_port_t ofp_port,
                 /* Forwarding is disabled by STP.  Let OFPP_NORMAL and the
                  * learning action look at the packet, then drop it. */
                 struct flow old_base_flow = ctx->base_flow;
-                size_t old_size = ctx->xout->odp_actions.size;
+                size_t old_size = ofpbuf_size(&ctx->xout->odp_actions);
                 mirror_mask_t old_mirrors = ctx->xout->mirrors;
                 xlate_table_action(ctx, flow->in_port.ofp_port, 0, true, true);
                 ctx->xout->mirrors = old_mirrors;
                 ctx->base_flow = old_base_flow;
-                ctx->xout->odp_actions.size = old_size;
+                ofpbuf_set_size(&ctx->xout->odp_actions, old_size);
             }
         }
 
@@ -1867,9 +1867,9 @@ xlate_resubmit_resource_check(struct xlate_ctx *ctx)
                     MAX_RESUBMIT_RECURSION);
     } else if (ctx->resubmits >= MAX_RESUBMITS) {
         VLOG_ERR_RL(&rl, "over %d resubmit actions", MAX_RESUBMITS);
-    } else if (ctx->xout->odp_actions.size > UINT16_MAX) {
+    } else if (ofpbuf_size(&ctx->xout->odp_actions) > UINT16_MAX) {
         VLOG_ERR_RL(&rl, "resubmits yielded over 64 kB of actions");
-    } else if (ctx->stack.size >= 65536) {
+    } else if (ofpbuf_size(&ctx->stack) >= 65536) {
         VLOG_ERR_RL(&rl, "resubmits yielded over 64 kB of stack");
     } else {
         return true;
@@ -1955,7 +1955,7 @@ xlate_group_bucket(struct xlate_ctx *ctx, const struct ofputil_bucket *bucket)
 
     ofpacts_execute_action_set(&action_list, &action_set);
     ctx->recurse++;
-    do_xlate_actions(action_list.data, action_list.size, ctx);
+    do_xlate_actions(ofpbuf_data(&action_list), ofpbuf_size(&action_list), ctx);
     ctx->recurse--;
 
     ofpbuf_uninit(&action_set);
@@ -2135,11 +2135,12 @@ execute_controller_action(struct xlate_ctx *ctx, int len,
                                           &ctx->xout->odp_actions,
                                           &ctx->xout->wc);
 
-    odp_execute_actions(NULL, packet, false, &md, ctx->xout->odp_actions.data,
-                        ctx->xout->odp_actions.size, NULL);
+    odp_execute_actions(NULL, packet, false, &md,
+                        ofpbuf_data(&ctx->xout->odp_actions),
+                        ofpbuf_size(&ctx->xout->odp_actions), NULL);
 
     pin = xmalloc(sizeof *pin);
-    pin->up.packet_len = packet->size;
+    pin->up.packet_len = ofpbuf_size(packet);
     pin->up.packet = ofpbuf_steal_data(packet);
     pin->up.reason = reason;
     pin->up.table_id = ctx->table_id;
@@ -2551,7 +2552,7 @@ xlate_action_set(struct xlate_ctx *ctx)
 
     ofpbuf_use_stub(&action_list, action_list_stub, sizeof action_list_stub);
     ofpacts_execute_action_set(&action_list, &ctx->action_set);
-    do_xlate_actions(action_list.data, action_list.size, ctx);
+    do_xlate_actions(ofpbuf_data(&action_list), ofpbuf_size(&action_list), ctx);
     ofpbuf_uninit(&action_list);
 }
 
@@ -2897,8 +2898,8 @@ xlate_out_copy(struct xlate_out *dst, const struct xlate_out *src)
 
     ofpbuf_use_stub(&dst->odp_actions, dst->odp_actions_stub,
                     sizeof dst->odp_actions_stub);
-    ofpbuf_put(&dst->odp_actions, src->odp_actions.data,
-               src->odp_actions.size);
+    ofpbuf_put(&dst->odp_actions, ofpbuf_data(&src->odp_actions),
+               ofpbuf_size(&src->odp_actions));
 }
 
 static struct skb_priority_to_dscp *
@@ -2943,8 +2944,8 @@ actions_output_to_local_port(const struct xlate_ctx *ctx)
     const struct nlattr *a;
     unsigned int left;
 
-    NL_ATTR_FOR_EACH_UNSAFE (a, left, ctx->xout->odp_actions.data,
-                             ctx->xout->odp_actions.size) {
+    NL_ATTR_FOR_EACH_UNSAFE (a, left, ofpbuf_data(&ctx->xout->odp_actions),
+                             ofpbuf_size(&ctx->xout->odp_actions)) {
         if (nl_attr_type(a) == OVS_ACTION_ATTR_OUTPUT
             && nl_attr_get_odp_port(a) == local_odp_port) {
             return true;
@@ -3131,7 +3132,7 @@ xlate_actions__(struct xlate_in *xin, struct xlate_out *xout)
 
         add_sflow_action(&ctx);
         add_ipfix_action(&ctx);
-        sample_actions_len = ctx.xout->odp_actions.size;
+        sample_actions_len = ofpbuf_size(&ctx.xout->odp_actions);
 
         if (tnl_may_send && (!in_port || may_receive(in_port, &ctx))) {
             do_xlate_actions(ofpacts, ofpacts_len, &ctx);
@@ -3139,11 +3140,11 @@ xlate_actions__(struct xlate_in *xin, struct xlate_out *xout)
             /* We've let OFPP_NORMAL and the learning action look at the
              * packet, so drop it now if forwarding is disabled. */
             if (in_port && !xport_stp_forward_state(in_port)) {
-                ctx.xout->odp_actions.size = sample_actions_len;
+                ofpbuf_set_size(&ctx.xout->odp_actions, sample_actions_len);
             }
         }
 
-        if (ctx.action_set.size) {
+        if (ofpbuf_size(&ctx.action_set)) {
             xlate_action_set(&ctx);
         }
 
@@ -3160,7 +3161,7 @@ xlate_actions__(struct xlate_in *xin, struct xlate_out *xout)
         }
     }
 
-    if (nl_attr_oversized(ctx.xout->odp_actions.size)) {
+    if (nl_attr_oversized(ofpbuf_size(&ctx.xout->odp_actions))) {
         /* These datapath actions are too big for a Netlink attribute, so we
          * can't hand them to the kernel directly.  dpif_execute() can execute
          * them one by one with help, so just mark the result as SLOW_ACTION to
diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c
index 7172cb216..ee97707c4 100644
--- a/ofproto/ofproto-dpif.c
+++ b/ofproto/ofproto-dpif.c
@@ -946,8 +946,8 @@ check_variable_length_userdata(struct dpif_backer *backer)
 
     /* Execute the actions.  On older datapaths this fails with ERANGE, on
      * newer datapaths it succeeds. */
-    execute.actions = actions.data;
-    execute.actions_len = actions.size;
+    execute.actions = ofpbuf_data(&actions);
+    execute.actions_len = ofpbuf_size(&actions);
     execute.packet = &packet;
     execute.md = PKT_METADATA_INITIALIZER(0);
     execute.needs_help = false;
@@ -1009,7 +1009,7 @@ check_max_mpls_depth(struct dpif_backer *backer)
         odp_flow_key_from_flow(&key, &flow, 0);
 
         error = dpif_flow_put(backer->dpif, DPIF_FP_CREATE | DPIF_FP_MODIFY,
-                              key.data, key.size, NULL, 0, NULL, 0, NULL);
+                              ofpbuf_data(&key), ofpbuf_size(&key), NULL, 0, NULL, 0, NULL);
         if (error && error != EEXIST) {
             if (error != EINVAL) {
                 VLOG_WARN("%s: MPLS stack length feature probe failed (%s)",
@@ -1018,7 +1018,7 @@ check_max_mpls_depth(struct dpif_backer *backer)
             break;
         }
 
-        error = dpif_flow_del(backer->dpif, key.data, key.size, NULL);
+        error = dpif_flow_del(backer->dpif, ofpbuf_data(&key), ofpbuf_size(&key), NULL);
         if (error) {
             VLOG_WARN("%s: failed to delete MPLS feature probe flow",
                       dpif_name(backer->dpif));
@@ -1117,8 +1117,8 @@ add_internal_flow(struct ofproto_dpif *ofproto, int id,
     fm.buffer_id = 0;
     fm.out_port = 0;
     fm.flags = 0;
-    fm.ofpacts = ofpacts->data;
-    fm.ofpacts_len = ofpacts->size;
+    fm.ofpacts = ofpbuf_data(ofpacts);
+    fm.ofpacts_len = ofpbuf_size(ofpacts);
 
     error = ofproto_flow_mod(&ofproto->up, &fm);
     if (error) {
@@ -2420,7 +2420,7 @@ bundle_send_learning_packets(struct ofbundle *bundle)
                                                            e->mac, e->vlan,
                                                            &port_void);
             /* Temporarily use l2 as a private pointer (see below). */
-            ovs_assert(learning_packet->l2 == learning_packet->data);
+            ovs_assert(learning_packet->l2 == ofpbuf_data(learning_packet));
             learning_packet->l2 = port_void;
             list_push_back(&packets, &learning_packet->list_node);
         }
@@ -2433,7 +2433,7 @@ bundle_send_learning_packets(struct ofbundle *bundle)
         void *port_void = learning_packet->l2;
 
         /* Restore l2. */
-        learning_packet->l2 = learning_packet->data;
+        learning_packet->l2 = ofpbuf_data(learning_packet);
         ret = ofproto_dpif_send_packet(port_void, learning_packet);
         if (ret) {
             error = ret;
@@ -3005,8 +3005,8 @@ ofproto_dpif_execute_actions(struct ofproto_dpif *ofproto,
     if (in_port == OFPP_NONE) {
         in_port = OFPP_LOCAL;
     }
-    execute.actions = xout.odp_actions.data;
-    execute.actions_len = xout.odp_actions.size;
+    execute.actions = ofpbuf_data(&xout.odp_actions);
+    execute.actions_len = ofpbuf_size(&xout.odp_actions);
     execute.packet = packet;
     execute.md.tunnel = flow->tunnel;
     execute.md.skb_priority = flow->skb_priority;
@@ -3517,7 +3517,7 @@ ofproto_dpif_send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet
 
     ovs_mutex_lock(&ofproto->stats_mutex);
     ofproto->stats.tx_packets++;
-    ofproto->stats.tx_bytes += packet->size;
+    ofproto->stats.tx_bytes += ofpbuf_size(packet);
     ovs_mutex_unlock(&ofproto->stats_mutex);
     return error;
 }
@@ -3731,7 +3731,8 @@ trace_format_odp(struct ds *result, int level, const char *title,
 
     ds_put_char_multiple(result, '\t', level);
     ds_put_format(result, "%s: ", title);
-    format_odp_actions(result, odp_actions->data, odp_actions->size);
+    format_odp_actions(result, ofpbuf_data(odp_actions),
+                               ofpbuf_size(odp_actions));
     ds_put_char(result, '\n');
 }
 
@@ -3855,7 +3856,8 @@ parse_flow_and_packet(int argc, const char *argv[],
             goto exit;
         }
 
-        if (xlate_receive(backer, NULL, odp_key.data, odp_key.size, flow,
+        if (xlate_receive(backer, NULL, ofpbuf_data(&odp_key),
+                          ofpbuf_size(&odp_key), flow,
                           ofprotop, NULL, NULL, NULL, NULL)) {
             error = "Invalid datapath flow";
             goto exit;
@@ -3883,7 +3885,7 @@ parse_flow_and_packet(int argc, const char *argv[],
 
     /* Generate a packet, if requested. */
     if (packet) {
-        if (!packet->size) {
+        if (!ofpbuf_size(packet)) {
             flow_compose(packet, flow);
         } else {
             struct pkt_metadata md = pkt_metadata_from_flow(flow);
@@ -3996,11 +3998,11 @@ ofproto_unixctl_trace_actions(struct unixctl_conn *conn, int argc,
         goto exit;
     }
     if (enforce_consistency) {
-        retval = ofpacts_check_consistency(ofpacts.data, ofpacts.size, &flow,
-                                           u16_to_ofp(ofproto->up.max_ports),
+        retval = ofpacts_check_consistency(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts),
+                                           &flow, u16_to_ofp(ofproto->up.max_ports),
                                            0, 0, usable_protocols);
     } else {
-        retval = ofpacts_check(ofpacts.data, ofpacts.size, &flow,
+        retval = ofpacts_check(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &flow,
                                u16_to_ofp(ofproto->up.max_ports), 0, 0,
                                &usable_protocols);
     }
@@ -4012,7 +4014,8 @@ ofproto_unixctl_trace_actions(struct unixctl_conn *conn, int argc,
         goto exit;
     }
 
-    ofproto_trace(ofproto, &flow, packet, ofpacts.data, ofpacts.size, &result);
+    ofproto_trace(ofproto, &flow, packet,
+                  ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &result);
     unixctl_command_reply(conn, ds_cstr(&result));
 
 exit:
@@ -4081,8 +4084,8 @@ ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow,
         trace_format_megaflow(ds, 0, "Megaflow", &trace);
 
         ds_put_cstr(ds, "Datapath actions: ");
-        format_odp_actions(ds, trace.xout.odp_actions.data,
-                           trace.xout.odp_actions.size);
+        format_odp_actions(ds, ofpbuf_data(&trace.xout.odp_actions),
+                           ofpbuf_size(&trace.xout.odp_actions));
 
         if (trace.xout.slow) {
             enum slow_path_reason slow;
diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c
index b2d6526c6..80336de90 100644
--- a/ofproto/ofproto.c
+++ b/ofproto/ofproto.c
@@ -5842,7 +5842,7 @@ static enum ofperr
 handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg)
     OVS_EXCLUDED(ofproto_mutex)
 {
-    const struct ofp_header *oh = msg->data;
+    const struct ofp_header *oh = ofpbuf_data(msg);
     enum ofptype type;
     enum ofperr error;
 
@@ -6015,7 +6015,7 @@ handle_openflow(struct ofconn *ofconn, const struct ofpbuf *ofp_msg)
 {
     int error = handle_openflow__(ofconn, ofp_msg);
     if (error && error != OFPROTO_POSTPONE) {
-        ofconn_send_error(ofconn, ofp_msg->data, error);
+        ofconn_send_error(ofconn, ofpbuf_data(ofp_msg), error);
     }
     COVERAGE_INC(ofproto_recv_openflow);
     return error != OFPROTO_POSTPONE;
diff --git a/tests/test-bundle.c b/tests/test-bundle.c
index 5e5ef525e..c7331eb3a 100644
--- a/tests/test-bundle.c
+++ b/tests/test-bundle.c
@@ -78,7 +78,7 @@ parse_bundle_actions(char *actions)
         ovs_fatal(0, "%s", error);
     }
 
-    action = ofpacts.data;
+    action = ofpbuf_data(&ofpacts);
     bundle = ofpact_get_BUNDLE(xmemdup(action, action->len));
     ofpbuf_uninit(&ofpacts);
 
diff --git a/tests/test-flows.c b/tests/test-flows.c
index a49814295..1868c5405 100644
--- a/tests/test-flows.c
+++ b/tests/test-flows.c
@@ -79,8 +79,8 @@ main(int argc OVS_UNUSED, char *argv[])
             errors++;
             printf("mismatch on packet #%d (1-based).\n", n);
             printf("Packet:\n");
-            ofp_print_packet(stdout, packet->data, packet->size);
-            ovs_hex_dump(stdout, packet->data, packet->size, 0, true);
+            ofp_print_packet(stdout, ofpbuf_data(packet), ofpbuf_size(packet));
+            ovs_hex_dump(stdout, ofpbuf_data(packet), ofpbuf_size(packet), 0, true);
             match_print(&match);
             printf("Expected flow:\n%s\n", exp_s);
             printf("Actually extracted flow:\n%s\n", got_s);
diff --git a/tests/test-netflow.c b/tests/test-netflow.c
index 392c6ec76..8cdb26b2c 100644
--- a/tests/test-netflow.c
+++ b/tests/test-netflow.c
@@ -161,8 +161,8 @@ print_netflow(struct ofpbuf *buf)
         putchar('\n');
     }
 
-    if (buf->size) {
-        printf("%"PRIu32" extra bytes after last record\n", buf->size);
+    if (ofpbuf_size(buf)) {
+        printf("%"PRIu32" extra bytes after last record\n", ofpbuf_size(buf));
     }
 }
 
@@ -213,7 +213,7 @@ main(int argc, char *argv[])
 
         ofpbuf_clear(&buf);
         do {
-            retval = read(sock, buf.data, buf.allocated);
+            retval = read(sock, ofpbuf_data(&buf), buf.allocated);
         } while (retval < 0 && errno == EINTR);
         if (retval > 0) {
             ofpbuf_put_uninit(&buf, retval);
diff --git a/tests/test-odp.c b/tests/test-odp.c
index d41db8480..442cc29c9 100644
--- a/tests/test-odp.c
+++ b/tests/test-odp.c
@@ -55,7 +55,7 @@ parse_keys(bool wc_keys)
 
         if (!wc_keys) {
             /* Convert odp_key to flow. */
-            fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
+            fitness = odp_flow_key_to_flow(ofpbuf_data(&odp_key), ofpbuf_size(&odp_key), &flow);
             switch (fitness) {
                 case ODP_FIT_PERFECT:
                     break;
@@ -77,9 +77,9 @@ parse_keys(bool wc_keys)
             ofpbuf_init(&odp_key, 0);
             odp_flow_key_from_flow(&odp_key, &flow, flow.in_port.odp_port);
 
-            if (odp_key.size > ODPUTIL_FLOW_KEY_BYTES) {
+            if (ofpbuf_size(&odp_key) > ODPUTIL_FLOW_KEY_BYTES) {
                 printf ("too long: %"PRIu32" > %d\n",
-                        odp_key.size, ODPUTIL_FLOW_KEY_BYTES);
+                        ofpbuf_size(&odp_key), ODPUTIL_FLOW_KEY_BYTES);
                 exit_code = 1;
             }
         }
@@ -87,10 +87,10 @@ parse_keys(bool wc_keys)
         /* Convert odp_key to string. */
         ds_init(&out);
         if (wc_keys) {
-            odp_flow_format(odp_key.data, odp_key.size,
-                            odp_mask.data, odp_mask.size, NULL, &out, false);
+            odp_flow_format(ofpbuf_data(&odp_key), ofpbuf_size(&odp_key),
+                            ofpbuf_data(&odp_mask), ofpbuf_size(&odp_mask), NULL, &out, false);
         } else {
-            odp_flow_key_format(odp_key.data, odp_key.size, &out);
+            odp_flow_key_format(ofpbuf_data(&odp_key), ofpbuf_size(&odp_key), &out);
         }
         puts(ds_cstr(&out));
         ds_destroy(&out);
@@ -125,7 +125,7 @@ parse_actions(void)
 
         /* Convert odp_actions back to string. */
         ds_init(&out);
-        format_odp_actions(&out, odp_actions.data, odp_actions.size);
+        format_odp_actions(&out, ofpbuf_data(&odp_actions), ofpbuf_size(&odp_actions));
         puts(ds_cstr(&out));
         ds_destroy(&out);
 
@@ -183,8 +183,8 @@ parse_filter(char *filter_parse)
             struct match match, match_filter;
             struct minimatch minimatch;
 
-            odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
-            odp_flow_key_to_mask(odp_mask.data, odp_mask.size, &wc.masks,
+            odp_flow_key_to_flow(ofpbuf_data(&odp_key), ofpbuf_size(&odp_key), &flow);
+            odp_flow_key_to_mask(ofpbuf_data(&odp_mask), ofpbuf_size(&odp_mask), &wc.masks,
                                  &flow);
             match_init(&match, &flow, &wc);
 
@@ -200,8 +200,8 @@ parse_filter(char *filter_parse)
         }
         /* Convert odp_key to string. */
         ds_init(&out);
-        odp_flow_format(odp_key.data, odp_key.size,
-                        odp_mask.data, odp_mask.size, NULL, &out, false);
+        odp_flow_format(ofpbuf_data(&odp_key), ofpbuf_size(&odp_key),
+                        ofpbuf_data(&odp_mask), ofpbuf_size(&odp_mask), NULL, &out, false);
         puts(ds_cstr(&out));
         ds_destroy(&out);
 
diff --git a/tests/test-sflow.c b/tests/test-sflow.c
index deebd8268..cad4af5a0 100644
--- a/tests/test-sflow.c
+++ b/tests/test-sflow.c
@@ -468,13 +468,13 @@ static void
 print_sflow(struct ofpbuf *buf)
 {
     char *dgram_buf;
-    int dgram_len = buf->size;
+    int dgram_len = ofpbuf_size(buf);
     struct sflow_xdr xdrDatagram;
     struct sflow_xdr *x = &xdrDatagram;
 
     memset(x, 0, sizeof *x);
     if (SFLOWXDR_try(x)) {
-        SFLOWXDR_assert(x, (dgram_buf = ofpbuf_try_pull(buf, buf->size)));
+        SFLOWXDR_assert(x, (dgram_buf = ofpbuf_try_pull(buf, ofpbuf_size(buf))));
         sflowxdr_init(x, dgram_buf, dgram_len);
         SFLOWXDR_assert(x, dgram_len >= SFLOW_MIN_LEN);
         process_datagram(x);
@@ -529,7 +529,7 @@ main(int argc, char *argv[])
 
         ofpbuf_clear(&buf);
         do {
-            retval = read(sock, buf.data, buf.allocated);
+            retval = read(sock, ofpbuf_data(&buf), buf.allocated);
         } while (retval < 0 && errno == EINTR);
         if (retval > 0) {
             ofpbuf_put_uninit(&buf, retval);
diff --git a/tests/test-vconn.c b/tests/test-vconn.c
index 76757f4ff..b7b57eb03 100644
--- a/tests/test-vconn.c
+++ b/tests/test-vconn.c
@@ -356,7 +356,7 @@ test_send_plain_hello(int argc OVS_UNUSED, char *argv[])
 
     hello = ofpraw_alloc_xid(OFPRAW_OFPT_HELLO, OFP10_VERSION,
                              htonl(0x12345678), 0);
-    test_send_hello(type, hello->data, hello->size, 0);
+    test_send_hello(type, ofpbuf_data(hello), ofpbuf_size(hello), 0);
     ofpbuf_delete(hello);
 }
 
@@ -374,7 +374,7 @@ test_send_long_hello(int argc OVS_UNUSED, char *argv[])
                              htonl(0x12345678), EXTRA_BYTES);
     ofpbuf_put_zeros(hello, EXTRA_BYTES);
     ofpmsg_update_length(hello);
-    test_send_hello(type, hello->data, hello->size, 0);
+    test_send_hello(type, ofpbuf_data(hello), ofpbuf_size(hello), 0);
     ofpbuf_delete(hello);
 }
 
@@ -388,7 +388,7 @@ test_send_echo_hello(int argc OVS_UNUSED, char *argv[])
 
     echo = ofpraw_alloc_xid(OFPRAW_OFPT_ECHO_REQUEST, OFP10_VERSION,
                              htonl(0x12345678), 0);
-    test_send_hello(type, echo->data, echo->size, EPROTO);
+    test_send_hello(type, ofpbuf_data(echo), ofpbuf_size(echo), EPROTO);
     ofpbuf_delete(echo);
 }
 
@@ -414,8 +414,8 @@ test_send_invalid_version_hello(int argc OVS_UNUSED, char *argv[])
 
     hello = ofpraw_alloc_xid(OFPRAW_OFPT_HELLO, OFP10_VERSION,
                              htonl(0x12345678), 0);
-    ((struct ofp_header *) hello->data)->version = 0;
-    test_send_hello(type, hello->data, hello->size, EPROTO);
+    ((struct ofp_header *) ofpbuf_data(hello))->version = 0;
+    test_send_hello(type, ofpbuf_data(hello), ofpbuf_size(hello), EPROTO);
     ofpbuf_delete(hello);
 }
 
diff --git a/utilities/ovs-dpctl.c b/utilities/ovs-dpctl.c
index 4b00118ab..ccc55b5e9 100644
--- a/utilities/ovs-dpctl.c
+++ b/utilities/ovs-dpctl.c
@@ -883,9 +883,10 @@ dpctl_put_flow(int argc, char *argv[], enum dpif_flow_put_flags flags)
     run(odp_actions_from_string(actions_s, NULL, &actions), "parsing actions");
 
     run(dpif_flow_put(dpif, flags,
-                      key.data, key.size,
-                      mask.size == 0 ? NULL : mask.data, mask.size,
-                      actions.data, actions.size,
+                      ofpbuf_data(&key), ofpbuf_size(&key),
+                      ofpbuf_size(&mask) == 0 ? NULL : ofpbuf_data(&mask),
+                      ofpbuf_size(&mask),
+                      ofpbuf_data(&actions), ofpbuf_size(&actions),
                       print_statistics ? &stats : NULL),
         "updating flow table");
 
@@ -952,7 +953,7 @@ dpctl_del_flow(int argc, char *argv[])
     run(odp_flow_from_string(key_s, &port_names, &key, &mask), "parsing flow key");
 
     run(dpif_flow_del(dpif,
-                      key.data, key.size,
+                      ofpbuf_data(&key), ofpbuf_size(&key),
                       print_statistics ? &stats : NULL), "deleting flow");
 
     simap_destroy(&port_names);
@@ -1005,7 +1006,7 @@ dpctl_parse_actions(int argc, char *argv[])
             "odp_actions_from_string");
 
         ds_init(&s);
-        format_odp_actions(&s, actions.data, actions.size);
+        format_odp_actions(&s, ofpbuf_data(&actions), ofpbuf_size(&actions));
         puts(ds_cstr(&s));
         ds_destroy(&s);
 
@@ -1141,10 +1142,10 @@ dpctl_normalize_actions(int argc, char *argv[])
         "odp_flow_key_from_string");
 
     ds_clear(&s);
-    odp_flow_format(keybuf.data, keybuf.size, NULL, 0, NULL, &s, verbosity);
+    odp_flow_format(ofpbuf_data(&keybuf), ofpbuf_size(&keybuf), NULL, 0, NULL, &s, verbosity);
     printf("input flow: %s\n", ds_cstr(&s));
 
-    run(odp_flow_key_to_flow(keybuf.data, keybuf.size, &flow),
+    run(odp_flow_key_to_flow(ofpbuf_data(&keybuf), ofpbuf_size(&keybuf), &flow),
         "odp_flow_key_to_flow");
     ofpbuf_uninit(&keybuf);
 
@@ -1156,12 +1157,12 @@ dpctl_normalize_actions(int argc, char *argv[])
 
     if (verbosity) {
         ds_clear(&s);
-        format_odp_actions(&s, odp_actions.data, odp_actions.size);
+        format_odp_actions(&s, ofpbuf_data(&odp_actions), ofpbuf_size(&odp_actions));
         printf("input actions: %s\n", ds_cstr(&s));
     }
 
     hmap_init(&actions_per_flow);
-    NL_ATTR_FOR_EACH (a, left, odp_actions.data, odp_actions.size) {
+    NL_ATTR_FOR_EACH (a, left, ofpbuf_data(&odp_actions), ofpbuf_size(&odp_actions)) {
         const struct ovs_action_push_vlan *push;
         switch(nl_attr_type(a)) {
         case OVS_ACTION_ATTR_POP_VLAN:
@@ -1192,7 +1193,7 @@ dpctl_normalize_actions(int argc, char *argv[])
     for (i = 0; i < n_afs; i++) {
         const struct actions_for_flow *af = afs[i];
 
-        sort_output_actions(af->actions.data, af->actions.size);
+        sort_output_actions(ofpbuf_data(&af->actions), ofpbuf_size(&af->actions));
 
         if (af->flow.vlan_tci != htons(0)) {
             printf("vlan(vid=%"PRIu16",pcp=%d): ",
@@ -1212,7 +1213,7 @@ dpctl_normalize_actions(int argc, char *argv[])
         }
 
         ds_clear(&s);
-        format_odp_actions(&s, af->actions.data, af->actions.size);
+        format_odp_actions(&s, ofpbuf_data(&af->actions), ofpbuf_size(&af->actions));
         puts(ds_cstr(&s));
     }
     ds_destroy(&s);
diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c
index 12942471e..d2d0687ff 100644
--- a/utilities/ovs-ofctl.c
+++ b/utilities/ovs-ofctl.c
@@ -468,7 +468,7 @@ dump_transaction(struct vconn *vconn, struct ofpbuf *request)
     ofpmsg_update_length(request);
     run(vconn_transact(vconn, request, &reply), "talking to %s",
         vconn_get_name(vconn));
-    ofp_print(stdout, reply->data, reply->size, verbosity + 1);
+    ofp_print(stdout, ofpbuf_data(reply), ofpbuf_size(reply), verbosity + 1);
     ofpbuf_delete(reply);
 }
 
@@ -487,13 +487,13 @@ dump_trivial_transaction(const char *vconn_name, enum ofpraw raw)
 static void
 dump_stats_transaction(struct vconn *vconn, struct ofpbuf *request)
 {
-    const struct ofp_header *request_oh = request->data;
+    const struct ofp_header *request_oh = ofpbuf_data(request);
     ovs_be32 send_xid = request_oh->xid;
     enum ofpraw request_raw;
     enum ofpraw reply_raw;
     bool done = false;
 
-    ofpraw_decode_partial(&request_raw, request->data, request->size);
+    ofpraw_decode_partial(&request_raw, ofpbuf_data(request), ofpbuf_size(request));
     reply_raw = ofpraw_stats_request_to_reply(request_raw,
                                               request_oh->version);
 
@@ -503,20 +503,20 @@ dump_stats_transaction(struct vconn *vconn, struct ofpbuf *request)
         struct ofpbuf *reply;
 
         run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
-        recv_xid = ((struct ofp_header *) reply->data)->xid;
+        recv_xid = ((struct ofp_header *) ofpbuf_data(reply))->xid;
         if (send_xid == recv_xid) {
             enum ofpraw raw;
 
-            ofp_print(stdout, reply->data, reply->size, verbosity + 1);
+            ofp_print(stdout, ofpbuf_data(reply), ofpbuf_size(reply), verbosity + 1);
 
-            ofpraw_decode(&raw, reply->data);
+            ofpraw_decode(&raw, ofpbuf_data(reply));
             if (ofptype_from_ofpraw(raw) == OFPTYPE_ERROR) {
                 done = true;
             } else if (raw == reply_raw) {
-                done = !ofpmp_more(reply->data);
+                done = !ofpmp_more(ofpbuf_data(reply));
             } else {
                 ovs_fatal(0, "received bad reply: %s",
-                          ofp_to_string(reply->data, reply->size,
+                          ofp_to_string(ofpbuf_data(reply), ofpbuf_size(reply),
                                         verbosity + 1));
             }
         } else {
@@ -556,7 +556,7 @@ transact_multiple_noreply(struct vconn *vconn, struct list *requests)
     run(vconn_transact_multiple_noreply(vconn, requests, &reply),
         "talking to %s", vconn_get_name(vconn));
     if (reply) {
-        ofp_print(stderr, reply->data, reply->size, verbosity + 2);
+        ofp_print(stderr, ofpbuf_data(reply), ofpbuf_size(reply), verbosity + 2);
         exit(1);
     }
     ofpbuf_delete(reply);
@@ -626,7 +626,7 @@ ofctl_show(int argc OVS_UNUSED, char *argv[])
     run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
 
     trunc = ofputil_switch_features_ports_trunc(reply);
-    ofp_print(stdout, reply->data, reply->size, verbosity + 1);
+    ofp_print(stdout, ofpbuf_data(reply), ofpbuf_size(reply), verbosity + 1);
 
     ofpbuf_delete(reply);
 
@@ -689,8 +689,8 @@ fetch_port_by_features(const char *vconn_name,
     run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
     vconn_close(vconn);
 
-    oh = reply->data;
-    if (ofptype_decode(&type, reply->data)
+    oh = ofpbuf_data(reply);
+    if (ofptype_decode(&type, ofpbuf_data(reply))
         || type != OFPTYPE_FEATURES_REPLY) {
         ovs_fatal(0, "%s: received bad features reply", vconn_name);
     }
@@ -733,7 +733,7 @@ fetch_port_by_stats(const char *vconn_name,
     bool found = false;
 
     request = ofpraw_alloc(OFPRAW_OFPST_PORT_DESC_REQUEST, OFP10_VERSION, 0);
-    send_xid = ((struct ofp_header *) request->data)->xid;
+    send_xid = ((struct ofp_header *) ofpbuf_data(request))->xid;
 
     open_vconn(vconn_name, &vconn);
     send_openflow_buffer(vconn, request);
@@ -742,9 +742,9 @@ fetch_port_by_stats(const char *vconn_name,
         struct ofpbuf *reply;
 
         run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
-        recv_xid = ((struct ofp_header *) reply->data)->xid;
+        recv_xid = ((struct ofp_header *) ofpbuf_data(reply))->xid;
         if (send_xid == recv_xid) {
-            struct ofp_header *oh = reply->data;
+            struct ofp_header *oh = ofpbuf_data(reply);
             enum ofptype type;
             struct ofpbuf b;
             uint16_t flags;
@@ -753,7 +753,7 @@ fetch_port_by_stats(const char *vconn_name,
             if (ofptype_pull(&type, &b)
                 || type != OFPTYPE_PORT_DESC_STATS_REPLY) {
                 ovs_fatal(0, "received bad reply: %s",
-                          ofp_to_string(reply->data, reply->size,
+                          ofp_to_string(ofpbuf_data(reply), ofpbuf_size(reply),
                                         verbosity + 1));
             }
 
@@ -858,7 +858,7 @@ try_set_protocol(struct vconn *vconn, enum ofputil_protocol want,
         run(vconn_transact_noreply(vconn, request, &reply),
             "talking to %s", vconn_get_name(vconn));
         if (reply) {
-            char *s = ofp_to_string(reply->data, reply->size, 2);
+            char *s = ofp_to_string(ofpbuf_data(reply), ofpbuf_size(reply), 2);
             VLOG_DBG("%s: failed to set protocol, switch replied: %s",
                      vconn_get_name(vconn), s);
             free(s);
@@ -991,7 +991,7 @@ ofctl_dump_flows(int argc, char *argv[])
         size_t i;
 
         vconn = prepare_dump_flows(argc, argv, false, &request);
-        send_xid = ((struct ofp_header *) request->data)->xid;
+        send_xid = ((struct ofp_header *) ofpbuf_data(request))->xid;
         send_openflow_buffer(vconn, request);
 
         fses = NULL;
@@ -1261,13 +1261,13 @@ openflow_from_hex(const char *hex, struct ofpbuf **msgp)
         return "Trailing garbage in hex data";
     }
 
-    if (msg->size < sizeof(struct ofp_header)) {
+    if (ofpbuf_size(msg) < sizeof(struct ofp_header)) {
         ofpbuf_delete(msg);
         return "Message too short for OpenFlow";
     }
 
-    oh = msg->data;
-    if (msg->size != ntohs(oh->length)) {
+    oh = ofpbuf_data(msg);
+    if (ofpbuf_size(msg) != ntohs(oh->length)) {
         ofpbuf_delete(msg);
         return "Message size does not match length in OpenFlow header";
     }
@@ -1300,7 +1300,7 @@ ofctl_send(struct unixctl_conn *conn, int argc,
         }
 
         fprintf(stderr, "send: ");
-        ofp_print(stderr, msg->data, msg->size, verbosity);
+        ofp_print(stderr, ofpbuf_data(msg), ofpbuf_size(msg), verbosity);
 
         error = vconn_send_block(vconn, msg);
         if (error) {
@@ -1449,8 +1449,8 @@ monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests)
                 free(s);
             }
 
-            ofptype_decode(&type, b->data);
-            ofp_print(stderr, b->data, b->size, verbosity + 2);
+            ofptype_decode(&type, ofpbuf_data(b));
+            ofp_print(stderr, ofpbuf_data(b), ofpbuf_size(b), verbosity + 2);
 
             switch ((int) type) {
             case OFPTYPE_BARRIER_REPLY:
@@ -1464,7 +1464,7 @@ monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests)
                 if (reply_to_echo_requests) {
                     struct ofpbuf *reply;
 
-                    reply = make_echo_reply(b->data);
+                    reply = make_echo_reply(ofpbuf_data(b));
                     retval = vconn_send_block(vconn, reply);
                     if (retval) {
                         ovs_fatal(retval, "failed to send echo reply");
@@ -1543,7 +1543,7 @@ ofctl_monitor(int argc, char *argv[])
             run(vconn_transact_noreply(vconn, spif, &reply),
                 "talking to %s", vconn_get_name(vconn));
             if (reply) {
-                char *s = ofp_to_string(reply->data, reply->size, 2);
+                char *s = ofp_to_string(ofpbuf_data(reply), ofpbuf_size(reply), 2);
                 VLOG_DBG("%s: failed to set packet in format to nxm, controller"
                         " replied: %s. Falling back to the switch default.",
                         vconn_get_name(vconn), s);
@@ -1604,7 +1604,7 @@ ofctl_probe(int argc OVS_UNUSED, char *argv[])
     open_vconn(argv[1], &vconn);
     request = make_echo_request(vconn_get_version(vconn));
     run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]);
-    if (reply->size != sizeof(struct ofp_header)) {
+    if (ofpbuf_size(reply) != sizeof(struct ofp_header)) {
         ovs_fatal(0, "reply does not match request");
     }
     ofpbuf_delete(reply);
@@ -1630,8 +1630,8 @@ ofctl_packet_out(int argc, char *argv[])
 
     po.buffer_id = UINT32_MAX;
     po.in_port = str_to_port_no(argv[1], argv[2]);
-    po.ofpacts = ofpacts.data;
-    po.ofpacts_len = ofpacts.size;
+    po.ofpacts = ofpbuf_data(&ofpacts);
+    po.ofpacts_len = ofpbuf_size(&ofpacts);
 
     protocol = open_vconn(argv[1], &vconn);
     for (i = 4; i < argc; i++) {
@@ -1643,8 +1643,8 @@ ofctl_packet_out(int argc, char *argv[])
             ovs_fatal(0, "%s", error_msg);
         }
 
-        po.packet = packet->data;
-        po.packet_len = packet->size;
+        po.packet = ofpbuf_data(packet);
+        po.packet_len = ofpbuf_size(packet);
         opo = ofputil_encode_packet_out(&po, protocol);
         transact_noreply(vconn, opo);
         ofpbuf_delete(packet);
@@ -1835,7 +1835,7 @@ ofctl_ofp_parse(int argc OVS_UNUSED, char *argv[])
             ovs_fatal(0, "%s: unexpected end of file mid-message", filename);
         }
 
-        ofp_print(stdout, b.data, b.size, verbosity + 2);
+        ofp_print(stdout, ofpbuf_data(&b), ofpbuf_size(&b), verbosity + 2);
     }
     ofpbuf_uninit(&b);
 
@@ -1894,16 +1894,17 @@ ofctl_ofp_parse_pcap(int argc OVS_UNUSED, char *argv[])
                 is_openflow_port(flow.tp_dst, argv + 2))) {
             struct ofpbuf *payload = tcp_reader_run(reader, &flow, packet);
             if (payload) {
-                while (payload->size >= sizeof(struct ofp_header)) {
+                while (ofpbuf_size(payload) >= sizeof(struct ofp_header)) {
                     const struct ofp_header *oh;
+                    void *data = ofpbuf_data(payload);
                     int length;
 
                     /* Align OpenFlow on 8-byte boundary for safe access. */
-                    ofpbuf_shift(payload, -((intptr_t) payload->data & 7));
+                    ofpbuf_shift(payload, -((intptr_t) data & 7));
 
-                    oh = payload->data;
+                    oh = ofpbuf_data(payload);
                     length = ntohs(oh->length);
-                    if (payload->size < length) {
+                    if (ofpbuf_size(payload) < length) {
                         break;
                     }
 
@@ -1921,7 +1922,7 @@ ofctl_ofp_parse_pcap(int argc OVS_UNUSED, char *argv[])
                     printf(IP_FMT".%"PRIu16" > "IP_FMT".%"PRIu16":\n",
                            IP_ARGS(flow.nw_src), ntohs(flow.tp_src),
                            IP_ARGS(flow.nw_dst), ntohs(flow.tp_dst));
-                    ofp_print(stdout, payload->data, length, verbosity + 1);
+                    ofp_print(stdout, ofpbuf_data(payload), length, verbosity + 1);
                     ofpbuf_pull(payload, length);
                 }
             }
@@ -1959,18 +1960,18 @@ ofctl_ping(int argc, char *argv[])
         run(vconn_transact(vconn, ofpbuf_clone(request), &reply), "transact");
         xgettimeofday(&end);
 
-        rpy_hdr = reply->data;
+        rpy_hdr = ofpbuf_data(reply);
         if (ofptype_pull(&type, reply)
             || type != OFPTYPE_ECHO_REPLY
-            || reply->size != payload
+            || ofpbuf_size(reply) != payload
             || memcmp(ofpbuf_get_l3(request), ofpbuf_get_l3(reply), payload)) {
             printf("Reply does not match request.  Request:\n");
-            ofp_print(stdout, request, request->size, verbosity + 2);
+            ofp_print(stdout, request, ofpbuf_size(request), verbosity + 2);
             printf("Reply:\n");
-            ofp_print(stdout, reply, reply->size, verbosity + 2);
+            ofp_print(stdout, reply, ofpbuf_size(reply), verbosity + 2);
         }
         printf("%"PRIu32" bytes from %s: xid=%08"PRIx32" time=%.1f ms\n",
-               reply->size, argv[1], ntohl(rpy_hdr->xid),
+               ofpbuf_size(reply), argv[1], ntohl(rpy_hdr->xid),
                    (1000*(double)(end.tv_sec - start.tv_sec))
                    + (.001*(end.tv_usec - start.tv_usec)));
         ofpbuf_delete(request);
@@ -2377,12 +2378,12 @@ recv_flow_stats_reply(struct vconn *vconn, ovs_be32 send_xid,
             do {
                 run(vconn_recv_block(vconn, &reply),
                     "OpenFlow packet receive failed");
-            } while (((struct ofp_header *) reply->data)->xid != send_xid);
+            } while (((struct ofp_header *) ofpbuf_data(reply))->xid != send_xid);
 
-            error = ofptype_decode(&type, reply->data);
+            error = ofptype_decode(&type, ofpbuf_data(reply));
             if (error || type != OFPTYPE_FLOW_STATS_REPLY) {
                 ovs_fatal(0, "received bad reply: %s",
-                          ofp_to_string(reply->data, reply->size,
+                          ofp_to_string(ofpbuf_data(reply), ofpbuf_size(reply),
                                         verbosity + 1));
             }
         }
@@ -2432,7 +2433,7 @@ read_flows_from_switch(struct vconn *vconn,
     fsr.table_id = 0xff;
     fsr.cookie = fsr.cookie_mask = htonll(0);
     request = ofputil_encode_flow_stats_request(&fsr, protocol);
-    send_xid = ((struct ofp_header *) request->data)->xid;
+    send_xid = ((struct ofp_header *) ofpbuf_data(request))->xid;
     send_openflow_buffer(vconn, request);
 
     reply = NULL;
@@ -2735,7 +2736,7 @@ ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms,
         struct ofpbuf *msg;
 
         msg = ofputil_encode_flow_mod(fm, protocol);
-        ofp_print(stdout, msg->data, msg->size, verbosity);
+        ofp_print(stdout, ofpbuf_data(msg), ofpbuf_size(msg), verbosity);
         ofpbuf_delete(msg);
 
         free(fm->ofpacts);
@@ -2828,7 +2829,7 @@ ofctl_parse_nxm__(bool oxm)
             } else {
                 match_len = nx_put_match(&nx_match, &match,
                                          cookie, cookie_mask);
-                out = nx_match_to_string(nx_match.data, match_len);
+                out = nx_match_to_string(ofpbuf_data(&nx_match), match_len);
             }
 
             puts(out);
@@ -2910,8 +2911,8 @@ ofctl_parse_ofp10_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 
         /* Convert to ofpacts. */
         ofpbuf_init(&ofpacts, 0);
-        size = of10_in.size;
-        error = ofpacts_pull_openflow_actions(&of10_in, of10_in.size,
+        size = ofpbuf_size(&of10_in);
+        error = ofpacts_pull_openflow_actions(&of10_in, ofpbuf_size(&of10_in),
                                               OFP10_VERSION, &ofpacts);
         if (error) {
             printf("bad OF1.1 actions: %s\n\n", ofperr_get_name(error));
@@ -2924,17 +2925,17 @@ ofctl_parse_ofp10_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
         /* Print cls_rule. */
         ds_init(&s);
         ds_put_cstr(&s, "actions=");
-        ofpacts_format(ofpacts.data, ofpacts.size, &s);
+        ofpacts_format(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &s);
         puts(ds_cstr(&s));
         ds_destroy(&s);
 
         /* Convert back to ofp10 actions and print differences from input. */
         ofpbuf_init(&of10_out, 0);
-        ofpacts_put_openflow_actions(ofpacts.data, ofpacts.size, &of10_out,
+        ofpacts_put_openflow_actions(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &of10_out,
                                      OFP10_VERSION);
 
-        print_differences("", of10_in.data, of10_in.size,
-                          of10_out.data, of10_out.size);
+        print_differences("", ofpbuf_data(&of10_in), ofpbuf_size(&of10_in),
+                          ofpbuf_data(&of10_out), ofpbuf_size(&of10_out));
         putchar('\n');
 
         ofpbuf_uninit(&ofpacts);
@@ -2980,9 +2981,9 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
         if (ofpbuf_put_hex(&match_expout, ds_cstr(&expout), NULL)[0] != '\0') {
             ovs_fatal(0, "Trailing garbage in hex data");
         }
-        if (match_expout.size != sizeof(struct ofp10_match)) {
+        if (ofpbuf_size(&match_expout) != sizeof(struct ofp10_match)) {
             ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE,
-                      match_expout.size, sizeof(struct ofp10_match));
+                      ofpbuf_size(&match_expout), sizeof(struct ofp10_match));
         }
 
         /* Parse hex bytes for input. */
@@ -2995,18 +2996,18 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
         if (ofpbuf_put_hex(&match_in, ds_cstr(&in), NULL)[0] != '\0') {
             ovs_fatal(0, "Trailing garbage in hex data");
         }
-        if (match_in.size != sizeof(struct ofp10_match)) {
+        if (ofpbuf_size(&match_in) != sizeof(struct ofp10_match)) {
             ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE,
-                      match_in.size, sizeof(struct ofp10_match));
+                      ofpbuf_size(&match_in), sizeof(struct ofp10_match));
         }
 
         /* Convert to cls_rule and print. */
-        ofputil_match_from_ofp10_match(match_in.data, &match);
+        ofputil_match_from_ofp10_match(ofpbuf_data(&match_in), &match);
         match_print(&match);
 
         /* Convert back to ofp10_match and print differences from input. */
         ofputil_match_to_ofp10_match(&match, &match_out);
-        print_differences("", match_expout.data, match_expout.size,
+        print_differences("", ofpbuf_data(&match_expout), ofpbuf_size(&match_expout),
                           &match_out, sizeof match_out);
 
         /* Normalize, then convert and compare again. */
@@ -3044,13 +3045,13 @@ ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
         if (ofpbuf_put_hex(&match_in, ds_cstr(&in), NULL)[0] != '\0') {
             ovs_fatal(0, "Trailing garbage in hex data");
         }
-        if (match_in.size != sizeof(struct ofp11_match)) {
+        if (ofpbuf_size(&match_in) != sizeof(struct ofp11_match)) {
             ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE,
-                      match_in.size, sizeof(struct ofp11_match));
+                      ofpbuf_size(&match_in), sizeof(struct ofp11_match));
         }
 
         /* Convert to match. */
-        error = ofputil_match_from_ofp11_match(match_in.data, &match);
+        error = ofputil_match_from_ofp11_match(ofpbuf_data(&match_in), &match);
         if (error) {
             printf("bad ofp11_match: %s\n\n", ofperr_get_name(error));
             ofpbuf_uninit(&match_in);
@@ -3063,7 +3064,7 @@ ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
         /* Convert back to ofp11_match and print differences from input. */
         ofputil_match_to_ofp11_match(&match, &match_out);
 
-        print_differences("", match_in.data, match_in.size,
+        print_differences("", ofpbuf_data(&match_in), ofpbuf_size(&match_in),
                           &match_out, sizeof match_out);
         putchar('\n');
 
@@ -3098,8 +3099,8 @@ ofctl_parse_ofp11_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 
         /* Convert to ofpacts. */
         ofpbuf_init(&ofpacts, 0);
-        size = of11_in.size;
-        error = ofpacts_pull_openflow_actions(&of11_in, of11_in.size,
+        size = ofpbuf_size(&of11_in);
+        error = ofpacts_pull_openflow_actions(&of11_in, ofpbuf_size(&of11_in),
                                               OFP11_VERSION, &ofpacts);
         if (error) {
             printf("bad OF1.1 actions: %s\n\n", ofperr_get_name(error));
@@ -3112,17 +3113,17 @@ ofctl_parse_ofp11_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
         /* Print cls_rule. */
         ds_init(&s);
         ds_put_cstr(&s, "actions=");
-        ofpacts_format(ofpacts.data, ofpacts.size, &s);
+        ofpacts_format(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &s);
         puts(ds_cstr(&s));
         ds_destroy(&s);
 
         /* Convert back to ofp11 actions and print differences from input. */
         ofpbuf_init(&of11_out, 0);
-        ofpacts_put_openflow_actions(ofpacts.data, ofpacts.size, &of11_out,
+        ofpacts_put_openflow_actions(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &of11_out,
                                      OFP11_VERSION);
 
-        print_differences("", of11_in.data, of11_in.size,
-                          of11_out.data, of11_out.size);
+        print_differences("", ofpbuf_data(&of11_in), ofpbuf_size(&of11_in),
+                          ofpbuf_data(&of11_out), ofpbuf_size(&of11_out));
         putchar('\n');
 
         ofpbuf_uninit(&ofpacts);
@@ -3168,14 +3169,14 @@ ofctl_parse_ofp11_instructions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 
         /* Convert to ofpacts. */
         ofpbuf_init(&ofpacts, 0);
-        size = of11_in.size;
-        error = ofpacts_pull_openflow_instructions(&of11_in, of11_in.size,
+        size = ofpbuf_size(&of11_in);
+        error = ofpacts_pull_openflow_instructions(&of11_in, ofpbuf_size(&of11_in),
                                                    OFP11_VERSION, &ofpacts);
         if (!error) {
             /* Verify actions, enforce consistency. */
             struct flow flow;
             memset(&flow, 0, sizeof flow);
-            error = ofpacts_check_consistency(ofpacts.data, ofpacts.size,
+            error = ofpacts_check_consistency(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts),
                                               &flow, OFPP_MAX,
                                               table_id ? atoi(table_id) : 0,
                                               255, OFPUTIL_P_OF11_STD);
@@ -3191,18 +3192,18 @@ ofctl_parse_ofp11_instructions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
         /* Print cls_rule. */
         ds_init(&s);
         ds_put_cstr(&s, "actions=");
-        ofpacts_format(ofpacts.data, ofpacts.size, &s);
+        ofpacts_format(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &s);
         puts(ds_cstr(&s));
         ds_destroy(&s);
 
         /* Convert back to ofp11 instructions and print differences from
          * input. */
         ofpbuf_init(&of11_out, 0);
-        ofpacts_put_openflow_instructions(ofpacts.data, ofpacts.size,
+        ofpacts_put_openflow_instructions(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts),
                                           &of11_out, OFP13_VERSION);
 
-        print_differences("", of11_in.data, of11_in.size,
-                          of11_out.data, of11_out.size);
+        print_differences("", ofpbuf_data(&of11_in), ofpbuf_size(&of11_in),
+                          ofpbuf_data(&of11_out), ofpbuf_size(&of11_out));
         putchar('\n');
 
         ofpbuf_uninit(&ofpacts);
@@ -3289,7 +3290,7 @@ ofctl_check_vlan(int argc OVS_UNUSED, char *argv[])
     /* Convert to and from NXM. */
     ofpbuf_init(&nxm, 0);
     nxm_match_len = nx_put_match(&nxm, &match, htonll(0), htonll(0));
-    nxm_s = nx_match_to_string(nxm.data, nxm_match_len);
+    nxm_s = nx_match_to_string(ofpbuf_data(&nxm), nxm_match_len);
     error = nx_pull_match(&nxm, nxm_match_len, &nxm_match, NULL, NULL);
     printf("NXM: %s -> ", nxm_s);
     if (error) {
@@ -3395,19 +3396,19 @@ ofctl_encode_error_reply(int argc OVS_UNUSED, char *argv[])
     if (ofpbuf_put_hex(&request, argv[2], NULL)[0] != '\0') {
         ovs_fatal(0, "Trailing garbage in hex data");
     }
-    if (request.size < sizeof(struct ofp_header)) {
+    if (ofpbuf_size(&request) < sizeof(struct ofp_header)) {
         ovs_fatal(0, "Request too short");
     }
 
-    oh = request.data;
-    if (request.size != ntohs(oh->length)) {
+    oh = ofpbuf_data(&request);
+    if (ofpbuf_size(&request) != ntohs(oh->length)) {
         ovs_fatal(0, "Request size inconsistent");
     }
 
-    reply = ofperr_encode_reply(error, request.data);
+    reply = ofperr_encode_reply(error, ofpbuf_data(&request));
     ofpbuf_uninit(&request);
 
-    ovs_hex_dump(stdout, reply->data, reply->size, 0, false);
+    ovs_hex_dump(stdout, ofpbuf_data(reply), ofpbuf_size(reply), 0, false);
     ofpbuf_delete(reply);
 }
 
@@ -3423,7 +3424,7 @@ ofctl_ofp_print(int argc, char *argv[])
     if (ofpbuf_put_hex(&packet, argv[1], NULL)[0] != '\0') {
         ovs_fatal(0, "trailing garbage following hex bytes");
     }
-    ofp_print(stdout, packet.data, packet.size, argc > 2 ? atoi(argv[2]) : 2);
+    ofp_print(stdout, ofpbuf_data(&packet), ofpbuf_size(&packet), argc > 2 ? atoi(argv[2]) : 2);
     ofpbuf_uninit(&packet);
 }
 
@@ -3436,8 +3437,8 @@ ofctl_encode_hello(int argc OVS_UNUSED, char *argv[])
     struct ofpbuf *hello;
 
     hello = ofputil_encode_hello(bitmap);
-    ovs_hex_dump(stdout, hello->data, hello->size, 0, false);
-    ofp_print(stdout, hello->data, hello->size, verbosity);
+    ovs_hex_dump(stdout, ofpbuf_data(hello), ofpbuf_size(hello), 0, false);
+    ofp_print(stdout, ofpbuf_data(hello), ofpbuf_size(hello), verbosity);
     ofpbuf_delete(hello);
 }
 
diff --git a/vswitchd/bridge.c b/vswitchd/bridge.c
index db85856cc..80fdb541d 100644
--- a/vswitchd/bridge.c
+++ b/vswitchd/bridge.c
@@ -3650,8 +3650,8 @@ iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos)
     }
 
     if (iface->ofp_port != OFPP_NONE) {
-        const struct ofproto_port_queue *port_queues = queues_buf.data;
-        size_t n_queues = queues_buf.size / sizeof *port_queues;
+        const struct ofproto_port_queue *port_queues = ofpbuf_data(&queues_buf);
+        size_t n_queues = ofpbuf_size(&queues_buf) / sizeof *port_queues;
 
         ofproto_port_set_queues(iface->port->bridge->ofproto, iface->ofp_port,
                                 port_queues, n_queues);