ovsdb: Correct specification inconsistency between "lock" and "assert".
[openvswitch] / utilities / ovs-appctl.c
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
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 <errno.h>
20 #include <getopt.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <stdlib.h>
24
25 #include "command-line.h"
26 #include "daemon.h"
27 #include "dirs.h"
28 #include "dynamic-string.h"
29 #include "timeval.h"
30 #include "unixctl.h"
31 #include "util.h"
32
33 static void usage(void);
34 static const char *parse_command_line(int argc, char *argv[]);
35 static struct unixctl_client *connect_to_target(const char *target);
36
37 int
38 main(int argc, char *argv[])
39 {
40     struct unixctl_client *client;
41     const char *target;
42     struct ds request;
43     int code, error;
44     char *reply;
45     int i;
46
47     set_program_name(argv[0]);
48
49     /* Parse command line and connect to target. */
50     target = parse_command_line(argc, argv);
51     client = connect_to_target(target);
52
53     /* Compose request. */
54     ds_init(&request);
55     for (i = optind; i < argc; i++) {
56         if (i != optind) {
57             ds_put_char(&request, ' ');
58         }
59         ds_put_cstr(&request, argv[i]);
60     }
61
62     /* Transact request and process reply. */
63     error = unixctl_client_transact(client, ds_cstr(&request), &code, &reply);
64     if (error) {
65         ovs_fatal(error, "%s: transaction error", target);
66     }
67     if (code / 100 != 2) {
68         fputs(reply, stderr);
69         ovs_error(0, "%s: server returned reply code %03d", target, code);
70         exit(2);
71     }
72     fputs(reply, stdout);
73
74     unixctl_client_destroy(client);
75     free(reply);
76     ds_destroy(&request);
77
78     return 0;
79 }
80
81 static void
82 usage(void)
83 {
84     printf("\
85 %s, for querying and controlling Open vSwitch daemon\n\
86 usage: %s [TARGET] COMMAND [ARG...]\n\
87 Targets:\n\
88   -t, --target=TARGET  pidfile or socket to contact\n\
89 Common commands:\n\
90   help               List commands supported by the target\n\
91   version            Print version of the target\n\
92   vlog/list          List current logging levels\n\
93   vlog/set MODULE[:FACILITY[:LEVEL]]\n\
94       Set MODULE and FACILITY log level to LEVEL\n\
95       MODULE may be any valid module name or 'ANY'\n\
96       FACILITY may be 'syslog', 'console', 'file', or 'ANY' (default)\n\
97       LEVEL may be 'off', 'emer', 'err', 'warn', 'info', or 'dbg' (default)\n\
98   vlog/reopen        Make the program reopen its log file\n\
99 Other options:\n\
100   -h, --help         Print this helpful information\n\
101   -V, --version      Display ovs-appctl version information\n",
102            program_name, program_name);
103     exit(EXIT_SUCCESS);
104 }
105
106 static const char *
107 parse_command_line(int argc, char *argv[])
108 {
109     static const struct option long_options[] = {
110         {"target", required_argument, NULL, 't'},
111         {"execute", no_argument, NULL, 'e'},
112         {"help", no_argument, NULL, 'h'},
113         {"version", no_argument, NULL, 'V'},
114         {NULL, 0, NULL, 0},
115     };
116     const char *target;
117     int e_options;
118
119     target = NULL;
120     e_options = 0;
121     for (;;) {
122         int option;
123
124         option = getopt_long(argc, argv, "+t:hVe", long_options, NULL);
125         if (option == -1) {
126             break;
127         }
128         switch (option) {
129         case 't':
130             if (target) {
131                 ovs_fatal(0, "-t or --target may be specified only once");
132             }
133             target = optarg;
134             break;
135
136         case 'e':
137             /* We ignore -e for compatibility.  Older versions specified the
138              * command as the argument to -e.  Since the current version takes
139              * the command as non-option arguments and we say that -e has no
140              * arguments, this just works in the common case. */
141             if (e_options++) {
142                 ovs_fatal(0, "-e or --execute may be speciifed only once");
143             }
144             break;
145
146         case 'h':
147             usage();
148             break;
149
150         case 'V':
151             ovs_print_version(0, 0);
152             exit(EXIT_SUCCESS);
153
154         case '?':
155             exit(EXIT_FAILURE);
156
157         default:
158             NOT_REACHED();
159         }
160     }
161
162     if (optind >= argc) {
163         ovs_fatal(0, "at least one non-option argument is required "
164                   "(use --help for help)");
165     }
166
167     return target ? target : "ovs-vswitchd";
168 }
169
170 static struct unixctl_client *
171 connect_to_target(const char *target)
172 {
173     struct unixctl_client *client;
174     char *socket_name;
175     int error;
176
177     if (target[0] != '/') {
178         char *pidfile_name;
179         pid_t pid;
180
181         pidfile_name = xasprintf("%s/%s.pid", ovs_rundir(), target);
182         pid = read_pidfile(pidfile_name);
183         if (pid < 0) {
184             ovs_fatal(-pid, "cannot read pidfile \"%s\"", pidfile_name);
185         }
186         free(pidfile_name);
187         socket_name = xasprintf("%s/%s.%ld.ctl",
188                                 ovs_rundir(), target, (long int) pid);
189     } else {
190         socket_name = xstrdup(target);
191     }
192
193     error = unixctl_client_create(socket_name, &client);
194     if (error) {
195         ovs_fatal(error, "cannot connect to \"%s\"", socket_name);
196     }
197     free(socket_name);
198
199     return client;
200 }
201