static void
do_notify(struct ovs_cmdl_context *ctx)
{
struct jsonrpc_msg *msg;
struct jsonrpc *rpc;
struct json *params;
struct stream *stream;
const char *method;
char *string;
int error;
method = ctx->argv[2];
params = parse_json(ctx->argv[3]);
msg = jsonrpc_create_notify(method, params);
string = jsonrpc_msg_is_valid(msg);
if (string) {
ovs_fatal(0, "not a JSON RPC-valid notification: %s", string);
}
error = stream_open_block(jsonrpc_stream_open(ctx->argv[1], &stream,
DSCP_DEFAULT), &stream);
if (error) {
ovs_fatal(error, "could not open \"%s\"", ctx->argv[1]);
}
rpc = jsonrpc_open(stream);
error = jsonrpc_send_block(rpc, msg);
if (error) {
ovs_fatal(error, "could not send notification");
}
jsonrpc_close(rpc);
}
void
jsonrpc_session_close(struct jsonrpc_session *s)
{
if (s) {
jsonrpc_close(s->rpc);
reconnect_destroy(s->reconnect);
stream_close(s->stream);
pstream_close(s->pstream);
free(s);
}
}
static void
jsonrpc_session_disconnect(struct jsonrpc_session *s)
{
if (s->rpc) {
jsonrpc_error(s->rpc, EOF);
jsonrpc_close(s->rpc);
s->rpc = NULL;
s->seqno++;
} else if (s->stream) {
stream_close(s->stream);
s->stream = NULL;
s->seqno++;
}
}
static void
do_request(struct ovs_cmdl_context *ctx)
{
struct jsonrpc_msg *msg;
struct jsonrpc *rpc;
struct json *params;
struct stream *stream;
const char *method;
char *string;
int error;
method = ctx->argv[2];
params = parse_json(ctx->argv[3]);
msg = jsonrpc_create_request(method, params, NULL);
string = jsonrpc_msg_is_valid(msg);
if (string) {
ovs_fatal(0, "not a valid JSON-RPC request: %s", string);
}
error = stream_open_block(jsonrpc_stream_open(ctx->argv[1], &stream,
DSCP_DEFAULT), &stream);
if (error) {
ovs_fatal(error, "could not open \"%s\"", ctx->argv[1]);
}
rpc = jsonrpc_open(stream);
error = jsonrpc_send(rpc, msg);
if (error) {
ovs_fatal(error, "could not send request");
}
error = jsonrpc_recv_block(rpc, &msg);
if (error) {
ovs_fatal(error, "error waiting for reply");
}
print_and_free_json(jsonrpc_msg_to_json(msg));
jsonrpc_close(rpc);
}
static void
do_listen(struct ovs_cmdl_context *ctx)
{
struct pstream *pstream;
struct jsonrpc **rpcs;
size_t n_rpcs, allocated_rpcs;
bool done;
int error;
error = jsonrpc_pstream_open(ctx->argv[1], &pstream, DSCP_DEFAULT);
if (error) {
ovs_fatal(error, "could not listen on \"%s\"", ctx->argv[1]);
}
daemonize();
rpcs = NULL;
n_rpcs = allocated_rpcs = 0;
done = false;
for (;;) {
struct stream *stream;
size_t i;
/* Accept new connections. */
error = pstream_accept(pstream, &stream);
if (!error) {
if (n_rpcs >= allocated_rpcs) {
rpcs = x2nrealloc(rpcs, &allocated_rpcs, sizeof *rpcs);
}
rpcs[n_rpcs++] = jsonrpc_open(stream);
} else if (error != EAGAIN) {
ovs_fatal(error, "pstream_accept failed");
}
/* Service existing connections. */
for (i = 0; i < n_rpcs; ) {
struct jsonrpc *rpc = rpcs[i];
struct jsonrpc_msg *msg;
jsonrpc_run(rpc);
if (!jsonrpc_get_backlog(rpc)) {
error = jsonrpc_recv(rpc, &msg);
if (!error) {
error = handle_rpc(rpc, msg, &done);
jsonrpc_msg_destroy(msg);
} else if (error == EAGAIN) {
error = 0;
}
}
if (!error) {
error = jsonrpc_get_status(rpc);
}
if (error) {
jsonrpc_close(rpc);
ovs_error(error, "connection closed");
memmove(&rpcs[i], &rpcs[i + 1],
(n_rpcs - i - 1) * sizeof *rpcs);
n_rpcs--;
} else {
i++;
}
}
/* Wait for something to do. */
if (done && !n_rpcs) {
break;
}
pstream_wait(pstream);
for (i = 0; i < n_rpcs; i++) {
struct jsonrpc *rpc = rpcs[i];
jsonrpc_wait(rpc);
if (!jsonrpc_get_backlog(rpc)) {
jsonrpc_recv_wait(rpc);
}
}
poll_block();
}
free(rpcs);
pstream_close(pstream);
}
int
main(int argc, char *argv[])
{
const struct ovsdb_client_command *command;
char *database;
struct jsonrpc *rpc;
ovs_cmdl_proctitle_init(argc, argv);
set_program_name(argv[0]);
parse_options(argc, argv);
fatal_ignore_sigpipe();
daemon_become_new_user(false);
if (optind >= argc) {
ovs_fatal(0, "missing command name; use --help for help");
}
for (command = get_all_commands(); ; command++) {
if (!command->name) {
VLOG_FATAL("unknown command '%s'; use --help for help",
argv[optind]);
} else if (!strcmp(command->name, argv[optind])) {
break;
}
}
optind++;
if (command->need != NEED_NONE) {
if (argc - optind > command->min_args
&& (isalpha((unsigned char) argv[optind][0])
&& strchr(argv[optind], ':'))) {
rpc = open_jsonrpc(argv[optind++]);
} else {
char *sock = xasprintf("unix:%s/db.sock", ovs_rundir());
rpc = open_jsonrpc(sock);
free(sock);
}
} else {
rpc = NULL;
}
if (command->need == NEED_DATABASE) {
struct svec dbs;
svec_init(&dbs);
fetch_dbs(rpc, &dbs);
if (argc - optind > command->min_args
&& svec_contains(&dbs, argv[optind])) {
database = xstrdup(argv[optind++]);
} else if (dbs.n == 1) {
database = xstrdup(dbs.names[0]);
} else if (svec_contains(&dbs, "Open_vSwitch")) {
database = xstrdup("Open_vSwitch");
} else {
jsonrpc_close(rpc);
ovs_fatal(0, "no default database for `%s' command, please "
"specify a database name", command->name);
}
svec_destroy(&dbs);
} else {
database = NULL;
}
if (argc - optind < command->min_args ||
argc - optind > command->max_args) {
free(database);
VLOG_FATAL("invalid syntax for '%s' (use --help for help)",
command->name);
}
command->handler(rpc, database, argc - optind, argv + optind);
free(database);
jsonrpc_close(rpc);
if (ferror(stdout)) {
VLOG_FATAL("write to stdout failed");
}
if (ferror(stderr)) {
VLOG_FATAL("write to stderr failed");
}
return 0;
}
