]>
Commit | Line | Data |
---|---|---|
064af421 | 1 | /* |
2f51a7eb | 2 | * Copyright (c) 2008, 2009, 2010, 2011, 2013, 2014 Nicira, Inc. |
064af421 | 3 | * |
a14bc59f BP |
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: | |
064af421 | 7 | * |
a14bc59f BP |
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. | |
064af421 BP |
15 | */ |
16 | ||
17 | #include <config.h> | |
18 | #include "command-line.h" | |
19 | #include <getopt.h> | |
20 | #include <limits.h> | |
675febfa | 21 | #include <stdlib.h> |
3e8a2ad1 | 22 | #include "openvswitch/dynamic-string.h" |
728a8b14 | 23 | #include "ovs-thread.h" |
064af421 | 24 | #include "util.h" |
e6211adc | 25 | #include "openvswitch/vlog.h" |
279c9e03 BP |
26 | |
27 | VLOG_DEFINE_THIS_MODULE(command_line); | |
064af421 BP |
28 | |
29 | /* Given the GNU-style long options in 'options', returns a string that may be | |
30 | * passed to getopt() with the corresponding short options. The caller is | |
31 | * responsible for freeing the string. */ | |
32 | char * | |
5f383751 | 33 | ovs_cmdl_long_options_to_short_options(const struct option options[]) |
064af421 BP |
34 | { |
35 | char short_options[UCHAR_MAX * 3 + 1]; | |
36 | char *p = short_options; | |
d295e8e9 | 37 | |
064af421 BP |
38 | for (; options->name; options++) { |
39 | const struct option *o = options; | |
40 | if (o->flag == NULL && o->val > 0 && o->val <= UCHAR_MAX) { | |
41 | *p++ = o->val; | |
42 | if (o->has_arg == required_argument) { | |
43 | *p++ = ':'; | |
44 | } else if (o->has_arg == optional_argument) { | |
45 | *p++ = ':'; | |
46 | *p++ = ':'; | |
47 | } | |
48 | } | |
49 | } | |
50 | *p = '\0'; | |
d295e8e9 | 51 | |
064af421 BP |
52 | return xstrdup(short_options); |
53 | } | |
54 | ||
5f383751 | 55 | /* Given the 'struct ovs_cmdl_command' array, prints the usage of all commands. */ |
451de37e | 56 | void |
5f383751 | 57 | ovs_cmdl_print_commands(const struct ovs_cmdl_command commands[]) |
451de37e AW |
58 | { |
59 | struct ds ds = DS_EMPTY_INITIALIZER; | |
60 | ||
61 | ds_put_cstr(&ds, "The available commands are:\n"); | |
62 | for (; commands->name; commands++) { | |
5f383751 | 63 | const struct ovs_cmdl_command *c = commands; |
451de37e AW |
64 | ds_put_format(&ds, " %-23s %s\n", c->name, c->usage ? c->usage : ""); |
65 | } | |
66 | printf("%s", ds.string); | |
67 | ds_destroy(&ds); | |
68 | } | |
69 | ||
66fa2c88 AW |
70 | /* Given the GNU-style options in 'options', prints all options. */ |
71 | void | |
5f383751 | 72 | ovs_cmdl_print_options(const struct option options[]) |
66fa2c88 AW |
73 | { |
74 | struct ds ds = DS_EMPTY_INITIALIZER; | |
75 | ||
76 | for (; options->name; options++) { | |
77 | const struct option *o = options; | |
78 | const char *arg = o->has_arg == required_argument ? "ARG" : "[ARG]"; | |
79 | ||
80 | ds_put_format(&ds, "--%s%s%s\n", o->name, o->has_arg ? "=" : "", | |
81 | o->has_arg ? arg : ""); | |
82 | if (o->flag == NULL && o->val > 0 && o->val <= UCHAR_MAX) { | |
83 | ds_put_format(&ds, "-%c %s\n", o->val, o->has_arg ? arg : ""); | |
84 | } | |
85 | } | |
86 | printf("%s", ds.string); | |
87 | ds_destroy(&ds); | |
88 | } | |
89 | ||
1f4a7252 RM |
90 | static void |
91 | ovs_cmdl_run_command__(struct ovs_cmdl_context *ctx, | |
92 | const struct ovs_cmdl_command commands[], | |
93 | bool read_only) | |
675febfa | 94 | { |
5f383751 | 95 | const struct ovs_cmdl_command *p; |
675febfa | 96 | |
1636c761 | 97 | if (ctx->argc < 1) { |
675febfa BP |
98 | ovs_fatal(0, "missing command name; use --help for help"); |
99 | } | |
100 | ||
101 | for (p = commands; p->name != NULL; p++) { | |
1636c761 RB |
102 | if (!strcmp(p->name, ctx->argv[0])) { |
103 | int n_arg = ctx->argc - 1; | |
675febfa | 104 | if (n_arg < p->min_args) { |
279c9e03 BP |
105 | VLOG_FATAL( "'%s' command requires at least %d arguments", |
106 | p->name, p->min_args); | |
675febfa | 107 | } else if (n_arg > p->max_args) { |
279c9e03 BP |
108 | VLOG_FATAL("'%s' command takes at most %d arguments", |
109 | p->name, p->max_args); | |
675febfa | 110 | } else { |
1f4a7252 RM |
111 | if (p->mode == OVS_RW && read_only) { |
112 | VLOG_FATAL("'%s' command does not work in read only mode", | |
113 | p->name); | |
114 | } | |
1636c761 | 115 | p->handler(ctx); |
675febfa | 116 | if (ferror(stdout)) { |
279c9e03 | 117 | VLOG_FATAL("write to stdout failed"); |
675febfa BP |
118 | } |
119 | if (ferror(stderr)) { | |
279c9e03 | 120 | VLOG_FATAL("write to stderr failed"); |
675febfa BP |
121 | } |
122 | return; | |
123 | } | |
124 | } | |
125 | } | |
126 | ||
1636c761 | 127 | VLOG_FATAL("unknown command '%s'; use --help for help", ctx->argv[0]); |
675febfa | 128 | } |
1f4a7252 RM |
129 | |
130 | /* Runs the command designated by argv[0] within the command table specified by | |
131 | * 'commands', which must be terminated by a command whose 'name' member is a | |
132 | * null pointer. | |
133 | * | |
134 | * Command-line options should be stripped off, so that a typical invocation | |
135 | * looks like: | |
136 | * struct ovs_cmdl_context ctx = { | |
137 | * .argc = argc - optind, | |
138 | * .argv = argv + optind, | |
139 | * }; | |
140 | * ovs_cmdl_run_command(&ctx, my_commands); | |
141 | * */ | |
142 | void | |
143 | ovs_cmdl_run_command(struct ovs_cmdl_context *ctx, | |
144 | const struct ovs_cmdl_command commands[]) | |
145 | { | |
146 | ovs_cmdl_run_command__(ctx, commands, false); | |
147 | } | |
148 | ||
149 | void | |
150 | ovs_cmdl_run_command_read_only(struct ovs_cmdl_context *ctx, | |
151 | const struct ovs_cmdl_command commands[]) | |
152 | { | |
153 | ovs_cmdl_run_command__(ctx, commands, true); | |
154 | } | |
40f0707c BP |
155 | \f |
156 | /* Process title. */ | |
157 | ||
2f51a7eb | 158 | #ifdef __linux__ |
97be1538 EJ |
159 | static struct ovs_mutex proctitle_mutex = OVS_MUTEX_INITIALIZER; |
160 | ||
161 | /* Start of command-line arguments in memory. */ | |
162 | static char *argv_start OVS_GUARDED_BY(proctitle_mutex); | |
163 | ||
164 | /* Number of bytes of command-line arguments. */ | |
165 | static size_t argv_size OVS_GUARDED_BY(proctitle_mutex); | |
166 | ||
167 | /* Saved command-line arguments. */ | |
168 | static char *saved_proctitle OVS_GUARDED_BY(proctitle_mutex); | |
40f0707c BP |
169 | |
170 | /* Prepares the process so that proctitle_set() can later succeed. | |
171 | * | |
172 | * This modifies the argv[] array so that it no longer points into the memory | |
173 | * that it originally does. Later, proctitle_set() might overwrite that | |
174 | * memory. That means that this function should be called before anything else | |
175 | * that accesses the process's argv[] array. Ideally, it should be called | |
176 | * before anything else, period, at the very beginning of program | |
177 | * execution. */ | |
178 | void | |
5f383751 | 179 | ovs_cmdl_proctitle_init(int argc, char **argv) |
40f0707c BP |
180 | { |
181 | int i; | |
182 | ||
728a8b14 | 183 | assert_single_threaded(); |
40f0707c BP |
184 | if (!argc || !argv[0]) { |
185 | /* This situation should never occur, but... */ | |
186 | return; | |
187 | } | |
188 | ||
97be1538 | 189 | ovs_mutex_lock(&proctitle_mutex); |
40f0707c BP |
190 | /* Specialized version of first loop iteration below. */ |
191 | argv_start = argv[0]; | |
192 | argv_size = strlen(argv[0]) + 1; | |
193 | argv[0] = xstrdup(argv[0]); | |
194 | ||
195 | for (i = 1; i < argc; i++) { | |
196 | size_t size = strlen(argv[i]) + 1; | |
197 | ||
198 | /* Add (argv[i], strlen(argv[i])+1) to (argv_start, argv_size). */ | |
199 | if (argv[i] + size == argv_start) { | |
200 | /* Arguments grow downward in memory. */ | |
201 | argv_start -= size; | |
202 | argv_size += size; | |
203 | } else if (argv[i] == argv_start + argv_size) { | |
204 | /* Arguments grow upward in memory. */ | |
205 | argv_size += size; | |
206 | } else { | |
207 | /* Arguments not contiguous. (Is this really Linux?) */ | |
208 | } | |
209 | ||
210 | /* Copy out the old argument so we can reuse the space. */ | |
211 | argv[i] = xstrdup(argv[i]); | |
212 | } | |
97be1538 | 213 | ovs_mutex_unlock(&proctitle_mutex); |
40f0707c BP |
214 | } |
215 | ||
d86a6c09 EM |
216 | /* Changes the name of the process, as shown by "ps", to the program name |
217 | * followed by 'format', which is formatted as if by printf(). */ | |
40f0707c | 218 | void |
5f383751 | 219 | ovs_cmdl_proctitle_set(const char *format, ...) |
40f0707c BP |
220 | { |
221 | va_list args; | |
222 | int n; | |
223 | ||
97be1538 | 224 | ovs_mutex_lock(&proctitle_mutex); |
40f0707c | 225 | if (!argv_start || argv_size < 8) { |
97be1538 | 226 | goto out; |
40f0707c BP |
227 | } |
228 | ||
229 | if (!saved_proctitle) { | |
230 | saved_proctitle = xmemdup(argv_start, argv_size); | |
231 | } | |
232 | ||
233 | va_start(args, format); | |
d86a6c09 EM |
234 | n = snprintf(argv_start, argv_size, "%s: ", program_name); |
235 | if (n < argv_size) { | |
236 | n += vsnprintf(argv_start + n, argv_size - n, format, args); | |
237 | } | |
40f0707c BP |
238 | if (n >= argv_size) { |
239 | /* The name is too long, so add an ellipsis at the end. */ | |
240 | strcpy(&argv_start[argv_size - 4], "..."); | |
241 | } else { | |
242 | /* Fill the extra space with null bytes, so that trailing bytes don't | |
243 | * show up in the command line. */ | |
244 | memset(&argv_start[n], '\0', argv_size - n); | |
245 | } | |
246 | va_end(args); | |
97be1538 EJ |
247 | |
248 | out: | |
249 | ovs_mutex_unlock(&proctitle_mutex); | |
40f0707c BP |
250 | } |
251 | ||
252 | /* Restores the process's original command line, as seen by "ps". */ | |
253 | void | |
5f383751 | 254 | ovs_cmdl_proctitle_restore(void) |
40f0707c | 255 | { |
97be1538 | 256 | ovs_mutex_lock(&proctitle_mutex); |
40f0707c BP |
257 | if (saved_proctitle) { |
258 | memcpy(argv_start, saved_proctitle, argv_size); | |
259 | free(saved_proctitle); | |
260 | saved_proctitle = NULL; | |
261 | } | |
97be1538 | 262 | ovs_mutex_unlock(&proctitle_mutex); |
40f0707c | 263 | } |
2f51a7eb | 264 | #else /* !__linux__ */ |
40f0707c BP |
265 | /* Stubs that don't do anything on non-Linux systems. */ |
266 | ||
267 | void | |
5f383751 | 268 | ovs_cmdl_proctitle_init(int argc OVS_UNUSED, char **argv OVS_UNUSED) |
40f0707c BP |
269 | { |
270 | } | |
271 | ||
666afb55 YT |
272 | #if !(defined(__FreeBSD__) || defined(__NetBSD__)) |
273 | /* On these platforms we #define this to setproctitle. */ | |
40f0707c | 274 | void |
5f383751 | 275 | ovs_cmdl_proctitle_set(const char *format OVS_UNUSED, ...) |
40f0707c BP |
276 | { |
277 | } | |
fb301c74 | 278 | #endif |
40f0707c BP |
279 | |
280 | void | |
5f383751 | 281 | ovs_cmdl_proctitle_restore(void) |
40f0707c BP |
282 | { |
283 | } | |
2f51a7eb | 284 | #endif /* !__linux__ */ |