1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/*
* Copyright (c) 2008, 2009, 2010, 2011, 2013 Nicira, Inc.
*
* 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 "command-line.h"
#include <getopt.h>
#include <limits.h>
#include <stdlib.h>
#include "ovs-thread.h"
#include "util.h"
#include "vlog.h"
VLOG_DEFINE_THIS_MODULE(command_line);
/* Given the GNU-style long options in 'options', returns a string that may be
* passed to getopt() with the corresponding short options. The caller is
* responsible for freeing the string. */
char *
long_options_to_short_options(const struct option options[])
{
char short_options[UCHAR_MAX * 3 + 1];
char *p = short_options;
for (; options->name; options++) {
const struct option *o = options;
if (o->flag == NULL && o->val > 0 && o->val <= UCHAR_MAX) {
*p++ = o->val;
if (o->has_arg == required_argument) {
*p++ = ':';
} else if (o->has_arg == optional_argument) {
*p++ = ':';
*p++ = ':';
}
}
}
*p = '\0';
return xstrdup(short_options);
}
/* Runs the command designated by argv[0] within the command table specified by
* 'commands', which must be terminated by a command whose 'name' member is a
* null pointer.
*
* Command-line options should be stripped off, so that a typical invocation
* looks like "run_command(argc - optind, argv + optind, my_commands);". */
void
run_command(int argc, char *argv[], const struct command commands[])
{
const struct command *p;
if (argc < 1) {
ovs_fatal(0, "missing command name; use --help for help");
}
for (p = commands; p->name != NULL; p++) {
if (!strcmp(p->name, argv[0])) {
int n_arg = argc - 1;
if (n_arg < p->min_args) {
VLOG_FATAL( "'%s' command requires at least %d arguments",
p->name, p->min_args);
} else if (n_arg > p->max_args) {
VLOG_FATAL("'%s' command takes at most %d arguments",
p->name, p->max_args);
} else {
p->handler(argc, argv);
if (ferror(stdout)) {
VLOG_FATAL("write to stdout failed");
}
if (ferror(stderr)) {
VLOG_FATAL("write to stderr failed");
}
return;
}
}
}
VLOG_FATAL("unknown command '%s'; use --help for help", argv[0]);
}
/* Process title. */
#ifdef LINUX_DATAPATH
static char *argv_start; /* Start of command-line arguments in memory. */
static size_t argv_size; /* Number of bytes of command-line arguments. */
static char *saved_proctitle; /* Saved command-line arguments. */
/* Prepares the process so that proctitle_set() can later succeed.
*
* This modifies the argv[] array so that it no longer points into the memory
* that it originally does. Later, proctitle_set() might overwrite that
* memory. That means that this function should be called before anything else
* that accesses the process's argv[] array. Ideally, it should be called
* before anything else, period, at the very beginning of program
* execution. */
void
proctitle_init(int argc, char **argv)
{
int i;
assert_single_threaded();
if (!argc || !argv[0]) {
/* This situation should never occur, but... */
return;
}
/* Specialized version of first loop iteration below. */
argv_start = argv[0];
argv_size = strlen(argv[0]) + 1;
argv[0] = xstrdup(argv[0]);
for (i = 1; i < argc; i++) {
size_t size = strlen(argv[i]) + 1;
/* Add (argv[i], strlen(argv[i])+1) to (argv_start, argv_size). */
if (argv[i] + size == argv_start) {
/* Arguments grow downward in memory. */
argv_start -= size;
argv_size += size;
} else if (argv[i] == argv_start + argv_size) {
/* Arguments grow upward in memory. */
argv_size += size;
} else {
/* Arguments not contiguous. (Is this really Linux?) */
}
/* Copy out the old argument so we can reuse the space. */
argv[i] = xstrdup(argv[i]);
}
}
/* Changes the name of the process, as shown by "ps", to the program name
* followed by 'format', which is formatted as if by printf(). */
void
proctitle_set(const char *format, ...)
{
va_list args;
int n;
if (!argv_start || argv_size < 8) {
return;
}
if (!saved_proctitle) {
saved_proctitle = xmemdup(argv_start, argv_size);
}
va_start(args, format);
n = snprintf(argv_start, argv_size, "%s: ", program_name);
if (n < argv_size) {
n += vsnprintf(argv_start + n, argv_size - n, format, args);
}
if (n >= argv_size) {
/* The name is too long, so add an ellipsis at the end. */
strcpy(&argv_start[argv_size - 4], "...");
} else {
/* Fill the extra space with null bytes, so that trailing bytes don't
* show up in the command line. */
memset(&argv_start[n], '\0', argv_size - n);
}
va_end(args);
}
/* Restores the process's original command line, as seen by "ps". */
void
proctitle_restore(void)
{
if (saved_proctitle) {
memcpy(argv_start, saved_proctitle, argv_size);
free(saved_proctitle);
saved_proctitle = NULL;
}
}
#else /* !LINUX_DATAPATH*/
/* Stubs that don't do anything on non-Linux systems. */
void
proctitle_init(int argc OVS_UNUSED, char **argv OVS_UNUSED)
{
}
#if !(defined(__FreeBSD__) || defined(__NetBSD__))
/* On these platforms we #define this to setproctitle. */
void
proctitle_set(const char *format OVS_UNUSED, ...)
{
}
#endif
void
proctitle_restore(void)
{
}
#endif /* !LINUX_DATAPATH */
|
