[mirror_ovs.git] / tests / test-jsonrpc.c

/*
 * Copyright (c) 2009, 2010 Nicira Networks.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <config.h>

#include "jsonrpc.h"

#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>

#include "command-line.h"
#include "daemon.h"
#include "json.h"
#include "poll-loop.h"
#include "stream-ssl.h"
#include "stream.h"
#include "timeval.h"
#include "util.h"
#include "vlog.h"

static struct command all_commands[];

static void usage(void) NO_RETURN;
static void parse_options(int argc, char *argv[]);

int
main(int argc, char *argv[])
{
    proctitle_init(argc, argv);
    set_program_name(argv[0]);
    time_init();
    vlog_init();
    parse_options(argc, argv);
    run_command(argc - optind, argv + optind, all_commands);
    return 0;
}

static void
parse_options(int argc, char *argv[])
{
    enum {
        OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1
    };
    static struct option long_options[] = {
        {"verbose", optional_argument, 0, 'v'},
        {"help", no_argument, 0, 'h'},
        DAEMON_LONG_OPTIONS,
#ifdef HAVE_OPENSSL
        {"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT},
        STREAM_SSL_LONG_OPTIONS
#endif
        {0, 0, 0, 0},
    };
    char *short_options = long_options_to_short_options(long_options);

    for (;;) {
        int c = getopt_long(argc, argv, short_options, long_options, NULL);
        if (c == -1) {
            break;
        }

        switch (c) {
        case 'h':
            usage();

        case 'v':
            vlog_set_verbosity(optarg);
            break;

        DAEMON_OPTION_HANDLERS

#ifdef HAVE_OPENSSL
        STREAM_SSL_OPTION_HANDLERS

        case OPT_BOOTSTRAP_CA_CERT:
            stream_ssl_set_ca_cert_file(optarg, true);
            break;
#endif

        case '?':
            exit(EXIT_FAILURE);

        default:
            abort();
        }
    }
    free(short_options);
}

static void
usage(void)
{
    printf("%s: JSON-RPC test utility\n"
           "usage: %s [OPTIONS] COMMAND [ARG...]\n"
           "  listen LOCAL             listen for connections on LOCAL\n"
           "  request REMOTE METHOD PARAMS   send request, print reply\n"
           "  notify REMOTE METHOD PARAMS  send notification and exit\n",
           program_name, program_name);
    stream_usage("JSON-RPC", true, true, true);
    daemon_usage();
    vlog_usage();
    printf("\nOther options:\n"
           "  -h, --help                  display this help message\n");
    exit(EXIT_SUCCESS);
}
\f
/* Command helper functions. */

static struct json *
parse_json(const char *s)
{
    struct json *json = json_from_string(s);
    if (json->type == JSON_STRING) {
        ovs_fatal(0, "\"%s\": %s", s, json->u.string);
    }
    return json;
}

static void
print_and_free_json(struct json *json)
{
    char *string = json_to_string(json, JSSF_SORT);
    json_destroy(json);
    puts(string);
    free(string);
}
\f
/* Command implementations. */

static void
handle_rpc(struct jsonrpc *rpc, struct jsonrpc_msg *msg, bool *done)
{
    struct jsonrpc_msg *reply = NULL;
    if (msg->type == JSONRPC_REQUEST) {
        if (!strcmp(msg->method, "echo")) {
            reply = jsonrpc_create_reply(json_clone(msg->params), msg->id);
        } else {
            struct json *error = json_object_create();
            json_object_put_string(error, "error", "unknown method");
            reply = jsonrpc_create_error(error, msg->id);
            ovs_error(0, "unknown request %s", msg->method);
        }

    } else if (msg->type == JSONRPC_NOTIFY) {
        if (!strcmp(msg->method, "shutdown")) {
            *done = true;
        } else {
            jsonrpc_error(rpc, ENOTTY);
            ovs_error(0, "unknown notification %s", msg->method);
        }
    } else {
        jsonrpc_error(rpc, EPROTO);
        ovs_error(0, "unsolicited JSON-RPC reply or error");
    }

    if (reply) {
        jsonrpc_send(rpc, reply);
    }
}

static void
do_listen(int argc OVS_UNUSED, char *argv[])
{
    struct pstream *pstream;
    struct jsonrpc **rpcs;
    size_t n_rpcs, allocated_rpcs;
    bool done;
    int error;

    die_if_already_running();

    error = pstream_open(argv[1], &pstream);
    if (error) {
        ovs_fatal(error, "could not listen on \"%s\"", 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) {
                    handle_rpc(rpc, msg, &done);
                    jsonrpc_msg_destroy(msg);
                }
            }

            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);
}

static void
do_request(int argc OVS_UNUSED, char *argv[])
{
    struct jsonrpc_msg *msg;
    struct jsonrpc *rpc;
    struct json *params;
    struct stream *stream;
    const char *method;
    char *string;
    int error;

    method = argv[2];
    params = parse_json(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(argv[1], &stream);
    if (error) {
        ovs_fatal(error, "could not open \"%s\"", 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_notify(int argc OVS_UNUSED, char *argv[])
{
    struct jsonrpc_msg *msg;
    struct jsonrpc *rpc;
    struct json *params;
    struct stream *stream;
    const char *method;
    char *string;
    int error;

    method = argv[2];
    params = parse_json(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(argv[1], &stream);
    if (error) {
        ovs_fatal(error, "could not open \"%s\"", argv[1]);
    }
    rpc = jsonrpc_open(stream);

    error = jsonrpc_send_block(rpc, msg);
    if (error) {
        ovs_fatal(error, "could not send request");
    }
    jsonrpc_close(rpc);
}

static void
do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
{
    usage();
}

static struct command all_commands[] = {
    { "listen", 1, 1, do_listen },
    { "request", 3, 3, do_request },
    { "notify", 3, 3, do_notify },
    { "help", 0, INT_MAX, do_help },
    { NULL, 0, 0, NULL },
};
Commit	Line	Data
f2129093	1	/*
40f0707c	2	* Copyright (c) 2009, 2010 Nicira Networks.
f2129093 BP	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at:
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*/
	16
	17	#include <config.h>
	18
	19	#include "jsonrpc.h"
	20
	21	#include <errno.h>
	22	#include <fcntl.h>
	23	#include <getopt.h>
	24	#include <stdio.h>
	25	#include <stdlib.h>
	26
	27	#include "command-line.h"
	28	#include "daemon.h"
	29	#include "json.h"
	30	#include "poll-loop.h"
9467fe62	31	#include "stream-ssl.h"
f2129093 BP	32	#include "stream.h"
	33	#include "timeval.h"
	34	#include "util.h"
	35	#include "vlog.h"
	36
	37	static struct command all_commands[];
	38
	39	static void usage(void) NO_RETURN;
	40	static void parse_options(int argc, char *argv[]);
	41
	42	int
	43	main(int argc, char *argv[])
	44	{
40f0707c	45	proctitle_init(argc, argv);
f2129093 BP	46	set_program_name(argv[0]);
	47	time_init();
	48	vlog_init();
	49	parse_options(argc, argv);
	50	run_command(argc - optind, argv + optind, all_commands);
	51	return 0;
	52	}
	53
	54	static void
	55	parse_options(int argc, char *argv[])
	56	{
9467fe62 BP	57	enum {
	58	OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1
	59	};
f2129093 BP	60	static struct option long_options[] = {
	61	{"verbose", optional_argument, 0, 'v'},
	62	{"help", no_argument, 0, 'h'},
	63	DAEMON_LONG_OPTIONS,
9467fe62 BP	64	#ifdef HAVE_OPENSSL
	65	{"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT},
	66	STREAM_SSL_LONG_OPTIONS
	67	#endif
f2129093 BP	68	{0, 0, 0, 0},
	69	};
	70	char *short_options = long_options_to_short_options(long_options);
	71
	72	for (;;) {
	73	int c = getopt_long(argc, argv, short_options, long_options, NULL);
	74	if (c == -1) {
	75	break;
	76	}
	77
	78	switch (c) {
	79	case 'h':
	80	usage();
	81
	82	case 'v':
	83	vlog_set_verbosity(optarg);
	84	break;
	85
	86	DAEMON_OPTION_HANDLERS
	87
9467fe62 BP	88	#ifdef HAVE_OPENSSL
	89	STREAM_SSL_OPTION_HANDLERS
	90
	91	case OPT_BOOTSTRAP_CA_CERT:
	92	stream_ssl_set_ca_cert_file(optarg, true);
	93	break;
	94	#endif
	95
f2129093 BP	96	case '?':
	97	exit(EXIT_FAILURE);
	98
	99	default:
	100	abort();
	101	}
	102	}
	103	free(short_options);
	104	}
	105
	106	static void
	107	usage(void)
	108	{
	109	printf("%s: JSON-RPC test utility\n"
	110	"usage: %s [OPTIONS] COMMAND [ARG...]\n"
	111	" listen LOCAL listen for connections on LOCAL\n"
	112	" request REMOTE METHOD PARAMS send request, print reply\n"
	113	" notify REMOTE METHOD PARAMS send notification and exit\n",
	114	program_name, program_name);
9467fe62	115	stream_usage("JSON-RPC", true, true, true);
f2129093 BP	116	daemon_usage();
	117	vlog_usage();
	118	printf("\nOther options:\n"
	119	" -h, --help display this help message\n");
	120	exit(EXIT_SUCCESS);
	121	}
	122	\f
	123	/* Command helper functions. */
	124
	125	static struct json *
	126	parse_json(const char *s)
	127	{
	128	struct json *json = json_from_string(s);
	129	if (json->type == JSON_STRING) {
	130	ovs_fatal(0, "\"%s\": %s", s, json->u.string);
	131	}
	132	return json;
	133	}
	134
	135	static void
	136	print_and_free_json(struct json *json)
	137	{
	138	char *string = json_to_string(json, JSSF_SORT);
	139	json_destroy(json);
	140	puts(string);
	141	free(string);
	142	}
	143	\f
	144	/* Command implementations. */
	145
	146	static void
	147	handle_rpc(struct jsonrpc rpc, struct jsonrpc_msg msg, bool *done)
	148	{
	149	struct jsonrpc_msg *reply = NULL;
	150	if (msg->type == JSONRPC_REQUEST) {
	151	if (!strcmp(msg->method, "echo")) {
	152	reply = jsonrpc_create_reply(json_clone(msg->params), msg->id);
	153	} else {
	154	struct json *error = json_object_create();
	155	json_object_put_string(error, "error", "unknown method");
	156	reply = jsonrpc_create_error(error, msg->id);
	157	ovs_error(0, "unknown request %s", msg->method);
	158	}
	159
	160	} else if (msg->type == JSONRPC_NOTIFY) {
	161	if (!strcmp(msg->method, "shutdown")) {
	162	*done = true;
	163	} else {
	164	jsonrpc_error(rpc, ENOTTY);
	165	ovs_error(0, "unknown notification %s", msg->method);
	166	}
	167	} else {
	168	jsonrpc_error(rpc, EPROTO);
	169	ovs_error(0, "unsolicited JSON-RPC reply or error");
	170	}
	171
	172	if (reply) {
	173	jsonrpc_send(rpc, reply);
	174	}
	175	}
	176
	177	static void
c69ee87c	178	do_listen(int argc OVS_UNUSED, char *argv[])
f2129093 BP	179	{
	180	struct pstream *pstream;
	181	struct jsonrpc **rpcs;
	182	size_t n_rpcs, allocated_rpcs;
	183	bool done;
	184	int error;
	185
	186	die_if_already_running();
	187
	188	error = pstream_open(argv[1], &pstream);
	189	if (error) {
	190	ovs_fatal(error, "could not listen on \"%s\"", argv[1]);
	191	}
	192
	193	daemonize();
	194
	195	rpcs = NULL;
	196	n_rpcs = allocated_rpcs = 0;
	197	done = false;
	198	for (;;) {
	199	struct stream *stream;
	200	size_t i;
	201
	202	/* Accept new connections. */
	203	error = pstream_accept(pstream, &stream);
	204	if (!error) {
	205	if (n_rpcs >= allocated_rpcs) {
	206	rpcs = x2nrealloc(rpcs, &allocated_rpcs, sizeof *rpcs);
	207	}
	208	rpcs[n_rpcs++] = jsonrpc_open(stream);
	209	} else if (error != EAGAIN) {
	210	ovs_fatal(error, "pstream_accept failed");
	211	}
	212
	213	/* Service existing connections. */
	214	for (i = 0; i < n_rpcs; ) {
	215	struct jsonrpc *rpc = rpcs[i];
	216	struct jsonrpc_msg *msg;
	217
	218	jsonrpc_run(rpc);
	219	if (!jsonrpc_get_backlog(rpc)) {
	220	error = jsonrpc_recv(rpc, &msg);
	221	if (!error) {
	222	handle_rpc(rpc, msg, &done);
	223	jsonrpc_msg_destroy(msg);
	224	}
	225	}
	226
	227	error = jsonrpc_get_status(rpc);
	228	if (error) {
	229	jsonrpc_close(rpc);
	230	ovs_error(error, "connection closed");
	231	memmove(&rpcs[i], &rpcs[i + 1],
	232	(n_rpcs - i - 1) * sizeof *rpcs);
	233	n_rpcs--;
	234	} else {
	235	i++;
	236	}
	237	}
	238
	239	/* Wait for something to do. */
	240	if (done && !n_rpcs) {
	241	break;
	242	}
243	pstream_wait(pstream);
244	for (i = 0; i < n_rpcs; i++) {
245	struct jsonrpc *rpc = rpcs[i];
246
247	jsonrpc_wait(rpc);
248	if (!jsonrpc_get_backlog(rpc)) {
249	jsonrpc_recv_wait(rpc);
250	}
251	}
252	poll_block();
253	}
93ff0290 BP	254	free(rpcs);
93ff0290 BP	255	pstream_close(pstream);
f2129093 BP	256	}
f2129093 BP	257
f2129093	258	static void
c69ee87c	259	do_request(int argc OVS_UNUSED, char *argv[])
f2129093 BP	260	{
	261	struct jsonrpc_msg *msg;
	262	struct jsonrpc *rpc;
	263	struct json *params;
	264	struct stream *stream;
	265	const char *method;
	266	char *string;
	267	int error;
	268
	269	method = argv[2];
	270	params = parse_json(argv[3]);
20bed8be	271	msg = jsonrpc_create_request(method, params, NULL);
f2129093 BP	272	string = jsonrpc_msg_is_valid(msg);
	273	if (string) {
	274	ovs_fatal(0, "not a valid JSON-RPC request: %s", string);
	275	}
	276
	277	error = stream_open_block(argv[1], &stream);
	278	if (error) {
	279	ovs_fatal(error, "could not open \"%s\"", argv[1]);
	280	}
	281	rpc = jsonrpc_open(stream);
	282
	283	error = jsonrpc_send(rpc, msg);
	284	if (error) {
	285	ovs_fatal(error, "could not send request");
	286	}
	287
	288	error = jsonrpc_recv_block(rpc, &msg);
	289	if (error) {
	290	ovs_fatal(error, "error waiting for reply");
	291	}
	292	print_and_free_json(jsonrpc_msg_to_json(msg));
	293
	294	jsonrpc_close(rpc);
	295	}
	296
	297	static void
c69ee87c	298	do_notify(int argc OVS_UNUSED, char *argv[])
f2129093 BP	299	{
	300	struct jsonrpc_msg *msg;
	301	struct jsonrpc *rpc;
	302	struct json *params;
	303	struct stream *stream;
	304	const char *method;
	305	char *string;
	306	int error;
	307
	308	method = argv[2];
	309	params = parse_json(argv[3]);
	310	msg = jsonrpc_create_notify(method, params);
	311	string = jsonrpc_msg_is_valid(msg);
	312	if (string) {
	313	ovs_fatal(0, "not a JSON RPC-valid notification: %s", string);
	314	}
	315
	316	error = stream_open_block(argv[1], &stream);
	317	if (error) {
	318	ovs_fatal(error, "could not open \"%s\"", argv[1]);
	319	}
	320	rpc = jsonrpc_open(stream);
	321
	322	error = jsonrpc_send_block(rpc, msg);
	323	if (error) {
	324	ovs_fatal(error, "could not send request");
	325	}
	326	jsonrpc_close(rpc);
	327	}
	328
	329	static void
c69ee87c	330	do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
f2129093 BP	331	{
	332	usage();
	333	}
	334
	335	static struct command all_commands[] = {
	336	{ "listen", 1, 1, do_listen },
	337	{ "request", 3, 3, do_request },
	338	{ "notify", 3, 3, do_notify },
	339	{ "help", 0, INT_MAX, do_help },
	340	{ NULL, 0, 0, NULL },
	341	};