#include <time.h>
#include <unistd.h>
-#include "buffer.h"
#include "command-line.h"
#include "compiler.h"
#include "daemon.h"
-#include "dhcp.h"
#include "dhcp-client.h"
+#include "dhcp.h"
#include "dynamic-string.h"
#include "fault.h"
#include "flow.h"
#include "mac-learning.h"
#include "netdev.h"
#include "nicira-ext.h"
+#include "ofpbuf.h"
#include "openflow.h"
#include "packets.h"
#include "poll-loop.h"
struct half {
struct rconn *rconn;
- struct buffer *rxbuf;
+ struct ofpbuf *rxbuf;
int n_txq; /* No. of packets queued for tx on 'rconn'. */
};
static struct ofp_packet_in *get_ofp_packet_in(struct relay *);
static bool get_ofp_packet_eth_header(struct relay *, struct ofp_packet_in **,
struct eth_header **);
-static void get_ofp_packet_payload(struct ofp_packet_in *, struct buffer *);
+static void get_ofp_packet_payload(struct ofp_packet_in *, struct ofpbuf *);
struct switch_status;
struct status_reply;
/* Start listening for vlogconf requests. */
retval = vlog_server_listen(NULL, NULL);
if (retval) {
- fatal(retval, "Could not listen for vlog connections");
+ ofp_fatal(retval, "Could not listen for vlog connections");
}
die_if_already_running();
if (s.controller_name) {
retval = rconn_connect(remote_rconn, s.controller_name);
if (retval == EAFNOSUPPORT) {
- fatal(0, "No support for %s vconn", s.controller_name);
+ ofp_fatal(0, "No support for %s vconn", s.controller_name);
}
}
switch_status_register_category(switch_status, "remote",
retval = pvconn_open(name, &pvconn);
if (retval && retval != EAGAIN) {
- fatal(retval, "opening %s", name);
+ ofp_fatal(retval, "opening %s", name);
}
return pvconn;
}
static struct ofp_packet_in *
get_ofp_packet_in(struct relay *r)
{
- struct buffer *msg = r->halves[HALF_LOCAL].rxbuf;
+ struct ofpbuf *msg = r->halves[HALF_LOCAL].rxbuf;
struct ofp_header *oh = msg->data;
if (oh->type == OFPT_PACKET_IN) {
if (msg->size >= offsetof (struct ofp_packet_in, data)) {
const struct hook *h;
for (h = hooks; h < &hooks[n_hooks]; h++) {
if (h->packet_cb[i] && h->packet_cb[i](r, h->aux)) {
- buffer_delete(this->rxbuf);
+ ofpbuf_delete(this->rxbuf);
this->rxbuf = NULL;
progress = true;
break;
if (!retval) {
progress = true;
} else {
- buffer_delete(this->rxbuf);
+ ofpbuf_delete(this->rxbuf);
}
this->rxbuf = NULL;
}
for (i = 0; i < 2; i++) {
struct half *this = &r->halves[i];
rconn_destroy(this->rconn);
- buffer_delete(this->rxbuf);
+ ofpbuf_delete(this->rxbuf);
}
free(r);
}
port_watcher_local_packet_cb(struct relay *r, void *pw_)
{
struct port_watcher *pw = pw_;
- struct buffer *msg = r->halves[HALF_LOCAL].rxbuf;
+ struct ofpbuf *msg = r->halves[HALF_LOCAL].rxbuf;
struct ofp_header *oh = msg->data;
if (oh->type == OFPT_FEATURES_REPLY
port_watcher_remote_packet_cb(struct relay *r, void *pw_)
{
struct port_watcher *pw = pw_;
- struct buffer *msg = r->halves[HALF_REMOTE].rxbuf;
+ struct ofpbuf *msg = r->halves[HALF_REMOTE].rxbuf;
struct ofp_header *oh = msg->data;
if (oh->type == OFPT_PORT_MOD
struct port_watcher *pw = pw_;
if (!pw->got_feature_reply && time_now() >= pw->last_feature_request + 5) {
- struct buffer *b;
+ struct ofpbuf *b;
make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, &b);
rconn_send_with_limit(pw->local_rconn, b, &pw->n_txq, 1);
pw->last_feature_request = time_now();
struct ofp_phy_port *p;
struct ofp_port_mod *opm;
struct ofp_port_status *ops;
- struct buffer *b;
+ struct ofpbuf *b;
int idx;
idx = port_no_to_pw_idx(port_no);
struct ofp_packet_in *opi;
struct eth_header *eth;
struct llc_header *llc;
- struct buffer payload;
+ struct ofpbuf payload;
uint16_t port_no;
struct flow flow;
VLOG_DBG("non-LLC frame received on STP multicast address");
return false;
}
- llc = buffer_at_assert(&payload, sizeof *eth, sizeof *llc);
+ llc = ofpbuf_at_assert(&payload, sizeof *eth, sizeof *llc);
if (llc->llc_dsap != STP_LLC_DSAP) {
VLOG_DBG("bad DSAP 0x%02"PRIx8" received on STP multicast address",
llc->llc_dsap);
if (payload.size > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
payload.size = ntohs(eth->eth_type) + ETH_HEADER_LEN;
}
- if (buffer_try_pull(&payload, ETH_HEADER_LEN + LLC_HEADER_LEN)) {
+ if (ofpbuf_try_pull(&payload, ETH_HEADER_LEN + LLC_HEADER_LEN)) {
struct stp_port *p = stp_get_port(stp->stp, port_no);
stp_received_bpdu(p, payload.data, payload.size);
}
struct stp_data *stp = stp_;
struct eth_header *eth;
struct llc_header *llc;
- struct buffer pkt, *opo;
+ struct ofpbuf pkt, *opo;
/* Packet skeleton. */
- buffer_init(&pkt, ETH_HEADER_LEN + LLC_HEADER_LEN + bpdu_size);
- eth = buffer_put_uninit(&pkt, sizeof *eth);
- llc = buffer_put_uninit(&pkt, sizeof *llc);
- buffer_put(&pkt, bpdu, bpdu_size);
+ ofpbuf_init(&pkt, ETH_HEADER_LEN + LLC_HEADER_LEN + bpdu_size);
+ eth = ofpbuf_put_uninit(&pkt, sizeof *eth);
+ llc = ofpbuf_put_uninit(&pkt, sizeof *llc);
+ ofpbuf_put(&pkt, bpdu, bpdu_size);
/* 802.2 header. */
memcpy(eth->eth_dst, stp_eth_addr, ETH_ADDR_LEN);
llc->llc_cntl = STP_LLC_CNTL;
opo = make_unbuffered_packet_out(&pkt, OFPP_NONE, port_no);
- buffer_uninit(&pkt);
+ ofpbuf_uninit(&pkt);
rconn_send_with_limit(stp->local_rconn, opo, &stp->n_txq, OFPP_MAX);
}
retval = netdev_open(s->of_name, NETDEV_ETH_TYPE_NONE, &netdev);
if (retval) {
- fatal(retval, "Could not open %s device", s->of_name);
+ ofp_fatal(retval, "Could not open %s device", s->of_name);
}
memcpy(dpid, netdev_get_etheraddr(netdev), ETH_ADDR_LEN);
netdev_close(netdev);
};
static void
-queue_tx(struct rconn *rc, struct in_band_data *in_band, struct buffer *b)
+queue_tx(struct rconn *rc, struct in_band_data *in_band, struct ofpbuf *b)
{
rconn_send_with_limit(rc, b, &in_band->n_queued, 10);
}
struct rconn *rc = r->halves[HALF_LOCAL].rconn;
struct ofp_packet_in *opi;
struct eth_header *eth;
- struct buffer payload;
+ struct ofpbuf payload;
struct flow flow;
uint16_t in_port;
int out_port;
} else {
/* We don't know that MAC. Send along the packet without setting up a
* flow. */
- struct buffer *b;
+ struct ofpbuf *b;
if (ntohl(opi->buffer_id) == UINT32_MAX) {
b = make_unbuffered_packet_out(&payload, in_port, out_port);
} else {
}
static void
-get_ofp_packet_payload(struct ofp_packet_in *opi, struct buffer *payload)
+get_ofp_packet_payload(struct ofp_packet_in *opi, struct ofpbuf *payload)
{
payload->data = opi->data;
payload->size = ntohs(opi->header.length) - offsetof(struct ofp_packet_in,
retval = netdev_open(s->of_name, NETDEV_ETH_TYPE_NONE,
&in_band->of_device);
if (retval) {
- fatal(retval, "Could not open %s device", s->of_name);
+ ofp_fatal(retval, "Could not open %s device", s->of_name);
}
memcpy(in_band->mac, netdev_get_etheraddr(in_band->of_device),
ETH_ADDR_LEN);
struct rconn *remote_rconn;
/* One queue per physical port. */
- struct queue queues[OFPP_MAX];
+ struct ofp_queue queues[OFPP_MAX];
int n_queued; /* Sum over queues[*].n. */
int next_tx_port; /* Next port to check in round-robin. */
static void
drop_packet(struct rate_limiter *rl)
{
- struct queue *longest; /* Queue currently selected as longest. */
+ struct ofp_queue *longest; /* Queue currently selected as longest. */
int n_longest; /* # of queues of same length as 'longest'. */
- struct queue *q;
+ struct ofp_queue *q;
longest = &rl->queues[0];
n_longest = 1;
}
/* FIXME: do we want to pop the tail instead? */
- buffer_delete(queue_pop_head(longest));
+ ofpbuf_delete(queue_pop_head(longest));
rl->n_queued--;
}
/* Remove and return the next packet to transmit (in round-robin order). */
-static struct buffer *
+static struct ofpbuf *
dequeue_packet(struct rate_limiter *rl)
{
unsigned int i;
for (i = 0; i < OFPP_MAX; i++) {
unsigned int port = (rl->next_tx_port + i) % OFPP_MAX;
- struct queue *q = &rl->queues[port];
+ struct ofp_queue *q = &rl->queues[port];
if (q->n) {
rl->next_tx_port = (port + 1) % OFPP_MAX;
rl->n_queued--;
return false;
} else {
/* Otherwise queue it up for the periodic callback to drain out. */
- struct buffer *msg = r->halves[HALF_LOCAL].rxbuf;
+ struct ofpbuf *msg = r->halves[HALF_LOCAL].rxbuf;
int port = ntohs(opi->in_port) % OFPP_MAX;
if (rl->n_queued >= s->burst_limit) {
drop_packet(rl);
}
- queue_push_tail(&rl->queues[port], buffer_clone(msg));
+ queue_push_tail(&rl->queues[port], ofpbuf_clone(msg));
rl->n_queued++;
rl->n_limited++;
return true;
* because the TCP connection is responsible for buffering and there is
* no point in trying to transmit faster than the TCP connection can
* handle. */
- struct buffer *b = dequeue_packet(rl);
+ struct ofpbuf *b = dequeue_packet(rl);
if (rconn_send_with_limit(rl->remote_rconn, b, &rl->n_txq, 10)) {
rl->n_tx_dropped++;
}
{
struct switch_status *ss = ss_;
struct rconn *rc = r->halves[HALF_REMOTE].rconn;
- struct buffer *msg = r->halves[HALF_REMOTE].rxbuf;
+ struct ofpbuf *msg = r->halves[HALF_REMOTE].rxbuf;
struct switch_status_category *c;
struct nicira_header *request;
struct nicira_header *reply;
struct status_reply sr;
- struct buffer *b;
+ struct ofpbuf *b;
int retval;
if (msg->size < sizeof(struct nicira_header)) {
/* Bring ofX network device up. */
retval = netdev_open(s->of_name, NETDEV_ETH_TYPE_NONE, &netdev);
if (retval) {
- fatal(retval, "Could not open %s device", s->of_name);
+ ofp_fatal(retval, "Could not open %s device", s->of_name);
}
retval = netdev_turn_flags_on(netdev, NETDEV_UP, true);
if (retval) {
- fatal(retval, "Could not bring %s device up", s->of_name);
+ ofp_fatal(retval, "Could not bring %s device up", s->of_name);
}
netdev_close(netdev);
retval = dhclient_create(s->of_name, modify_dhcp_request,
validate_dhcp_offer, (void *) s, &dhcp);
if (retval) {
- fatal(retval, "Failed to initialize DHCP client");
+ ofp_fatal(retval, "Failed to initialize DHCP client");
}
dhclient_init(dhcp, 0);
} else if (!strcmp(optarg, "closed")) {
s->fail_mode = FAIL_CLOSED;
} else {
- fatal(0,
- "-f or --fail argument must be \"open\" or \"closed\"");
+ ofp_fatal(0, "-f or --fail argument must be \"open\" "
+ "or \"closed\"");
}
break;
case OPT_INACTIVITY_PROBE:
s->probe_interval = atoi(optarg);
if (s->probe_interval < 5) {
- fatal(0, "--inactivity-probe argument must be at least 5");
+ ofp_fatal(0, "--inactivity-probe argument must be at least 5");
}
break;
} else {
s->max_idle = atoi(optarg);
if (s->max_idle < 1 || s->max_idle > 65535) {
- fatal(0, "--max-idle argument must be between 1 and "
- "65535 or the word 'permanent'");
+ ofp_fatal(0, "--max-idle argument must be between 1 and "
+ "65535 or the word 'permanent'");
}
}
break;
case OPT_MAX_BACKOFF:
s->max_backoff = atoi(optarg);
if (s->max_backoff < 1) {
- fatal(0, "--max-backoff argument must be at least 1");
+ ofp_fatal(0, "--max-backoff argument must be at least 1");
} else if (s->max_backoff > 3600) {
s->max_backoff = 3600;
}
if (optarg) {
s->rate_limit = atoi(optarg);
if (s->rate_limit < 1) {
- fatal(0, "--rate-limit argument must be at least 1");
+ ofp_fatal(0, "--rate-limit argument must be at least 1");
}
} else {
s->rate_limit = 1000;
case OPT_BURST_LIMIT:
s->burst_limit = atoi(optarg);
if (s->burst_limit < 1) {
- fatal(0, "--burst-limit argument must be at least 1");
+ ofp_fatal(0, "--burst-limit argument must be at least 1");
}
break;
case 'l':
if (s->n_listeners >= MAX_MGMT) {
- fatal(0, "-l or --listen may be specified at most %d times",
- MAX_MGMT);
+ ofp_fatal(0,
+ "-l or --listen may be specified at most %d times",
+ MAX_MGMT);
}
s->listener_names[s->n_listeners++] = optarg;
break;
case 'm':
if (s->monitor_name) {
- fatal(0, "-m or --monitor may only be specified once");
+ ofp_fatal(0, "-m or --monitor may only be specified once");
}
s->monitor_name = optarg;
break;
argc -= optind;
argv += optind;
if (argc < 1 || argc > 2) {
- fatal(0, "need one or two non-option arguments; use --help for usage");
+ ofp_fatal(0, "need one or two non-option arguments; "
+ "use --help for usage");
}
/* Local and remote vconns. */
if (strncmp(s->nl_name, "nl:", 3)
|| strlen(s->nl_name) < 4
|| s->nl_name[strspn(s->nl_name + 3, "0123456789") + 3]) {
- fatal(0, "%s: argument is not of the form \"nl:DP_IDX\"", s->nl_name);
+ ofp_fatal(0, "%s: argument is not of the form \"nl:DP_IDX\"",
+ s->nl_name);
}
s->of_name = xasprintf("of%s", s->nl_name + 3);
s->controller_name = argc > 1 ? xstrdup(argv[1]) : NULL;
size_t length = regerror(retval, &s->accept_controller_regex, NULL, 0);
char *buffer = xmalloc(length);
regerror(retval, &s->accept_controller_regex, buffer, length);
- fatal(0, "%s: %s", accept_re, buffer);
+ ofp_fatal(0, "%s: %s", accept_re, buffer);
}
s->accept_controller_re = accept_re;
retval = netdev_open(s->of_name, NETDEV_ETH_TYPE_NONE, &netdev);
if (retval) {
- fatal(retval, "Could not open %s device", s->of_name);
+ ofp_fatal(retval, "Could not open %s device", s->of_name);
}
retval = netdev_get_flags(netdev, &flags);
if (retval) {
- fatal(retval, "Could not get flags for %s device", s->of_name);
+ ofp_fatal(retval, "Could not get flags for %s device", s->of_name);
}
s->in_band = (flags & NETDEV_UP) != 0;