#include "poll-loop.h"
#include "random.h"
#include "stream-ssl.h"
+#include "socket-util.h"
#include "timeval.h"
#include "unixctl.h"
#include "util.h"
static void run(int retval, const char *message, ...)
PRINTF_FORMAT(2, 3);
-static void run(int retval, const char *message, ...)
+static void
+run(int retval, const char *message, ...)
{
if (retval) {
va_list args;
\f
/* Generic commands. */
-static void
+static int
open_vconn_socket(const char *name, struct vconn **vconnp)
{
char *vconn_name = xasprintf("unix:%s", name);
- VLOG_DBG("connecting to %s", vconn_name);
- run(vconn_open_block(vconn_name, OFP10_VERSION, vconnp),
- "connecting to %s", vconn_name);
+ int error;
+
+ error = vconn_open(vconn_name, 0, vconnp, DSCP_DEFAULT);
+ if (error && error != ENOENT) {
+ ovs_fatal(0, "%s: failed to open socket (%s)", name,
+ strerror(error));
+ }
free(vconn_name);
+
+ return error;
}
static enum ofputil_protocol
enum ofputil_protocol protocol;
char *bridge_path;
int ofp_version;
- struct stat s;
+ int error;
bridge_path = xasprintf("%s/%s.%s", ovs_rundir(), name, default_suffix);
free(datapath_type);
if (strchr(name, ':')) {
- run(vconn_open_block(name, OFP10_VERSION, vconnp),
- "connecting to %s", name);
- } else if (!stat(name, &s) && S_ISSOCK(s.st_mode)) {
- open_vconn_socket(name, vconnp);
- } else if (!stat(bridge_path, &s) && S_ISSOCK(s.st_mode)) {
- open_vconn_socket(bridge_path, vconnp);
- } else if (!stat(socket_name, &s)) {
- if (!S_ISSOCK(s.st_mode)) {
- ovs_fatal(0, "cannot connect to %s: %s is not a socket",
- name, socket_name);
- }
- open_vconn_socket(socket_name, vconnp);
+ run(vconn_open_block(name, 0, vconnp), "connecting to %s", name);
+ } else if (!open_vconn_socket(name, vconnp)) {
+ /* Fall Through. */
+ } else if (!open_vconn_socket(bridge_path, vconnp)) {
+ /* Fall Through. */
+ } else if (!open_vconn_socket(socket_name, vconnp)) {
+ /* Fall Through. */
} else {
ovs_fatal(0, "%s is not a bridge or a socket", name);
}
free(bridge_path);
free(socket_name);
+ VLOG_DBG("connecting to %s", vconn_get_name(*vconnp));
+ error = vconn_connect_block(*vconnp);
+ if (error) {
+ ovs_fatal(0, "%s: failed to connect to socket (%s)", name,
+ strerror(error));
+ }
+
ofp_version = vconn_get_version(*vconnp);
protocol = ofputil_protocol_from_ofp_version(ofp_version);
if (!protocol) {
static uint16_t
str_to_port_no(const char *vconn_name, const char *port_name)
{
- uint16_t port_no = ofputil_port_from_string(port_name);
- if (port_no) {
+ uint16_t port_no;
+
+ if (ofputil_port_from_string(port_name, &port_no)) {
return port_no;
} else {
struct ofputil_phy_port pp;
request = ofputil_encode_set_protocol(*cur, want, &next);
if (!request) {
- return true;
+ return *cur == want;
}
run(vconn_transact_noreply(vconn, request, &reply),
static void
ofctl_queue_stats(int argc, char *argv[])
{
- struct ofp10_queue_stats_request *req;
struct ofpbuf *request;
struct vconn *vconn;
+ struct ofputil_queue_stats_request oqs;
open_vconn(argv[1], &vconn);
- request = ofpraw_alloc(OFPRAW_OFPST_QUEUE_REQUEST,
- vconn_get_version(vconn), 0);
- req = ofpbuf_put_zeros(request, sizeof *req);
if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) {
- req->port_no = htons(str_to_port_no(argv[1], argv[2]));
+ oqs.port_no = str_to_port_no(argv[1], argv[2]);
} else {
- req->port_no = htons(OFPP_ALL);
+ oqs.port_no = OFPP_ALL;
}
if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) {
- req->queue_id = htonl(atoi(argv[3]));
+ oqs.queue_id = atoi(argv[3]);
} else {
- req->queue_id = htonl(OFPQ_ALL);
+ oqs.queue_id = OFPQ_ALL;
}
- memset(req->pad, 0, sizeof req->pad);
-
+ request = ofputil_encode_queue_stats_request(vconn_get_version(vconn), &oqs);
dump_stats_transaction(vconn, request);
vconn_close(vconn);
}
set_packet_in_format(struct vconn *vconn,
enum nx_packet_in_format packet_in_format)
{
- struct ofpbuf *spif = ofputil_make_set_packet_in_format(packet_in_format);
+ struct ofpbuf *spif;
+
+ spif = ofputil_make_set_packet_in_format(vconn_get_version(vconn),
+ packet_in_format);
transact_noreply(vconn, spif);
VLOG_DBG("%s: using user-specified packet in format %s",
vconn_get_name(vconn),
} else {
struct ofpbuf *spif, *reply;
- spif = ofputil_make_set_packet_in_format(NXPIF_NXM);
+ spif = ofputil_make_set_packet_in_format(vconn_get_version(vconn),
+ NXPIF_NXM);
run(vconn_transact_noreply(vconn, spif, &reply),
"talking to %s", vconn_get_name(vconn));
if (reply) {
static void
ofctl_dump_ports(int argc, char *argv[])
{
- struct ofp10_port_stats_request *req;
struct ofpbuf *request;
struct vconn *vconn;
uint16_t port;
open_vconn(argv[1], &vconn);
- request = ofpraw_alloc(OFPRAW_OFPST_PORT_REQUEST,
- vconn_get_version(vconn), 0);
- req = ofpbuf_put_zeros(request, sizeof *req);
port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_NONE;
- req->port_no = htons(port);
+ request = ofputil_encode_dump_ports_request(vconn_get_version(vconn), port);
dump_stats_transaction(vconn, request);
vconn_close(vconn);
}
ofpbuf_uninit(&packet);
}
+/* "encode-hello BITMAP...": Encodes each BITMAP as an OpenFlow hello message
+ * and dumps each message in hex. */
+static void
+ofctl_encode_hello(int argc OVS_UNUSED, char *argv[])
+{
+ uint32_t bitmap = strtol(argv[1], NULL, 0);
+ 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);
+ ofpbuf_delete(hello);
+}
+
static const struct command all_commands[] = {
{ "show", 1, 1, ofctl_show },
{ "monitor", 1, 3, ofctl_monitor },
{ "check-vlan", 2, 2, ofctl_check_vlan },
{ "print-error", 1, 1, ofctl_print_error },
{ "ofp-print", 1, 2, ofctl_ofp_print },
+ { "encode-hello", 1, 1, ofctl_encode_hello },
{ NULL, 0, 0, NULL },
};