flowgrind_stop.c File Reference

Utility to instruct the Flowgrind daemon to stop all flows. More...

#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <xmlrpc-c/base.h>
#include <xmlrpc-c/client.h>
#include "common.h"
#include "fg_definitions.h"
#include "fg_error.h"
#include "fg_progname.h"
#include "fg_rpc_client.h"
#include "fg_argparser.h"

Go to the source code of this file.

Functions
int	main (int argc, char *argv[])
static void	stop_flows (const char *address)
static void	usage (short status)
	Print flowgrind-stop usage and exit. More...

Variables
static struct arg_parser	parser
	Command line option parser. More...
const char *	progname
	String containing name the program is called with. More...

Detailed Description

Utility to instruct the Flowgrind daemon to stop all flows.

Definition in file flowgrind_stop.c.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 141 of file flowgrind_stop.c.

{
        /* update progname from argv[0] */
        set_progname(argv[0]);
 
        const struct ap_Option options[] = {
                {'h', "help", ap_no, 0, 0},
                {'v', "version", ap_no, 0, 0},
                {0, 0, ap_no, 0, 0}
        };
 
        if (!ap_init(&parser, argc, (const char* const*) argv, options, 0))
                critx("could not allocate memory for option parser");
        if (ap_error(&parser)) {
                errx("%s", ap_error(&parser));
                usage(EXIT_FAILURE);
        }
 
        /* parse command line */
        for (int argind = 0; argind < ap_arguments(&parser); argind++) {
                const int code = ap_code(&parser, argind);
 
                switch (code) {
                case 0:
                        break;
                case 'h':
                        usage(EXIT_SUCCESS);
                        break;
                case 'v':
                        fprintf(stdout, "%s %s\n%s\n%s\n\n%s\n", progname,
                                FLOWGRIND_VERSION, FLOWGRIND_COPYRIGHT,
                                FLOWGRIND_COPYING, FLOWGRIND_AUTHORS);
                        exit(EXIT_SUCCESS);
                        break;
                default:
                        errx("uncaught option: %s", ap_argument(&parser, argind));
                        usage(EXIT_FAILURE);
                        break;
                }
        }
 
        if (!ap_arguments(&parser)) {
                errx("no address given");
                usage(EXIT_FAILURE);
        }
 
        xmlrpc_env rpc_env;
        xmlrpc_env_init(&rpc_env);
        xmlrpc_client_setup_global_const(&rpc_env);
 
        for (int argind = 0; argind < ap_arguments(&parser); argind++)
                /* if non-option, it is an address */
                if (!ap_code(&parser, argind))
                        stop_flows(ap_argument(&parser, argind));
 
        xmlrpc_env_clean(&rpc_env);
        xmlrpc_client_teardown_global_const();
        ap_free(&parser);
}

stop_flows()

static void stop_flows ( const char *  address )

static

Definition at line 87 of file flowgrind_stop.c.

{
        xmlrpc_env env;
        xmlrpc_client *client = 0;
        xmlrpc_value * resultP = 0;
        int port = DEFAULT_LISTEN_PORT;
        bool is_ipv6 = false;
        char *arg, *url = 0;
        char *rpc_address = arg = strdup(address);
        struct sockaddr_in6 source_in6;
        source_in6.sin6_family = AF_INET6;
 
        parse_rpc_address(&rpc_address, &port, &is_ipv6);
 
        if (is_ipv6 && (inet_pton(AF_INET6, rpc_address,
                (char*)&source_in6.sin6_addr) <= 0))
                errx("invalid IPv6 address '%s' for RPC",  rpc_address);
 
        if (port < 1 || port > 65535)
                errx("invalid port for RPC");
 
        int rc = 0;
        if (is_ipv6)
                rc = asprintf(&url, "http://[%s]:%d/RPC2", rpc_address, port);
        else
                rc = asprintf(&url, "http://%s:%d/RPC2", rpc_address, port);
 
        if (rc == -1)
                critx("could not allocate memory for RPC URL");
 
        printf("Stopping all flows on %s\n", url);
 
        /* Stop the flows */
        xmlrpc_env_init(&env);
        xmlrpc_client_create(&env, XMLRPC_CLIENT_NO_FLAGS, "Flowgrind", FLOWGRIND_VERSION, NULL, 0, &client);
        if (env.fault_occurred)
                goto cleanup;
 
        xmlrpc_client_call2f(&env, client, url, "stop_flow", &resultP,
                "({s:i})", "flow_id", -1); /* -1 stops all flows */
        if (resultP)
                xmlrpc_DECREF(resultP);
 
cleanup:
        if (env.fault_occurred) {
                warnx("could not stop flows on %s: %s (%d)",
                      url, env.fault_string, env.fault_code);
        }
        if (client)
                xmlrpc_client_destroy(client);
        xmlrpc_env_clean(&env);
        free_all(arg, url);
}

usage()

static void usage ( short  status )

static

Print flowgrind-stop usage and exit.

Definition at line 65 of file flowgrind_stop.c.

{
        /* Syntax error. Emit 'try help' to stderr and exit */
        if (status != EXIT_SUCCESS) {
                fprintf(stderr, "Try '%s -h' for more information\n", progname);
                exit(status);
        }
 
        fprintf(stdout,
                "Usage: %1$s [OPTION]... [ADDRESS]...\n"
                "Stop all flows on the daemons running at the given addresses.\n\n"
 
                "Mandatory arguments to long options are mandatory for short options too.\n"
                "  -h, --help     display this help and exit\n"
                "  -v, --version  print version information and exit\n\n"
 
                "Example:\n"
                "   %1$s localhost 127.2.3.4:5999 example.com\n",
                progname);
        exit(EXIT_SUCCESS);
}

Variable Documentation

parser

struct arg_parser parser

static

Command line option parser.

Definition at line 57 of file flowgrind_stop.c.

progname

const char* progname

String containing name the program is called with.

Definition at line 35 of file fg_progname.c.