From: Pravin Shelar Date: Sun, 30 Mar 2014 08:31:50 +0000 (-0700) Subject: ofpbuf: Introduce access api for base, data and size. X-Git-Tag: sliver-openvswitch-2.2.90-1~5^2~67 X-Git-Url: http://git.onelab.eu/?p=sliver-openvswitch.git;a=commitdiff_plain;h=1f317cb5c2aa446c4b0252634a4a70dcc3682f93 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 --- 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, "")) { - /* 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);