Line data Source code
1 : /* SPDX-License-Identifier: LGPL-2.1+ */
2 :
3 : #include <stdlib.h>
4 :
5 : #include "alloc-util.h"
6 : #include "all-units.h"
7 : #include "analyze-verify.h"
8 : #include "bus-error.h"
9 : #include "bus-util.h"
10 : #include "log.h"
11 : #include "manager.h"
12 : #include "pager.h"
13 : #include "path-util.h"
14 : #include "strv.h"
15 : #include "unit-name.h"
16 :
17 0 : static int prepare_filename(const char *filename, char **ret) {
18 : int r;
19 : const char *name;
20 0 : _cleanup_free_ char *abspath = NULL;
21 0 : _cleanup_free_ char *dir = NULL;
22 0 : _cleanup_free_ char *with_instance = NULL;
23 : char *c;
24 :
25 0 : assert(filename);
26 0 : assert(ret);
27 :
28 0 : r = path_make_absolute_cwd(filename, &abspath);
29 0 : if (r < 0)
30 0 : return r;
31 :
32 0 : name = basename(abspath);
33 0 : if (!unit_name_is_valid(name, UNIT_NAME_ANY))
34 0 : return -EINVAL;
35 :
36 0 : if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
37 0 : r = unit_name_replace_instance(name, "i", &with_instance);
38 0 : if (r < 0)
39 0 : return r;
40 : }
41 :
42 0 : dir = dirname_malloc(abspath);
43 0 : if (!dir)
44 0 : return -ENOMEM;
45 :
46 0 : c = path_join(dir, with_instance ?: name);
47 0 : if (!c)
48 0 : return -ENOMEM;
49 :
50 0 : *ret = c;
51 0 : return 0;
52 : }
53 :
54 0 : static int generate_path(char **var, char **filenames) {
55 : const char *old;
56 : char **filename;
57 :
58 0 : _cleanup_strv_free_ char **ans = NULL;
59 : int r;
60 :
61 0 : STRV_FOREACH(filename, filenames) {
62 : char *t;
63 :
64 0 : t = dirname_malloc(*filename);
65 0 : if (!t)
66 0 : return -ENOMEM;
67 :
68 0 : r = strv_consume(&ans, t);
69 0 : if (r < 0)
70 0 : return r;
71 : }
72 :
73 0 : assert_se(strv_uniq(ans));
74 :
75 : /* First, prepend our directories. Second, if some path was specified, use that, and
76 : * otherwise use the defaults. Any duplicates will be filtered out in path-lookup.c.
77 : * Treat explicit empty path to mean that nothing should be appended.
78 : */
79 0 : old = getenv("SYSTEMD_UNIT_PATH");
80 0 : if (!streq_ptr(old, "")) {
81 0 : if (!old)
82 0 : old = ":";
83 :
84 0 : r = strv_extend(&ans, old);
85 0 : if (r < 0)
86 0 : return r;
87 : }
88 :
89 0 : *var = strv_join(ans, ":");
90 0 : if (!*var)
91 0 : return -ENOMEM;
92 :
93 0 : return 0;
94 : }
95 :
96 0 : static int verify_socket(Unit *u) {
97 : int r;
98 :
99 0 : assert(u);
100 :
101 0 : if (u->type != UNIT_SOCKET)
102 0 : return 0;
103 :
104 : /* Cannot run this without the service being around */
105 :
106 : /* This makes sure instance is created if necessary. */
107 0 : r = socket_instantiate_service(SOCKET(u));
108 0 : if (r < 0)
109 0 : return log_unit_error_errno(u, r, "Socket cannot be started, failed to create instance: %m");
110 :
111 : /* This checks both type of sockets */
112 0 : if (UNIT_ISSET(SOCKET(u)->service)) {
113 : Service *service;
114 :
115 0 : service = SERVICE(UNIT_DEREF(SOCKET(u)->service));
116 0 : log_unit_debug(u, "Using %s", UNIT(service)->id);
117 :
118 0 : if (UNIT(service)->load_state != UNIT_LOADED) {
119 0 : log_unit_error(u, "Service %s not loaded, %s cannot be started.", UNIT(service)->id, u->id);
120 0 : return -ENOENT;
121 : }
122 : }
123 :
124 0 : return 0;
125 : }
126 :
127 0 : static int verify_executable(Unit *u, ExecCommand *exec) {
128 0 : if (!exec)
129 0 : return 0;
130 :
131 0 : if (access(exec->path, X_OK) < 0)
132 0 : return log_unit_error_errno(u, errno, "Command %s is not executable: %m", exec->path);
133 :
134 0 : return 0;
135 : }
136 :
137 0 : static int verify_executables(Unit *u) {
138 : ExecCommand *exec;
139 0 : int r = 0, k;
140 : unsigned i;
141 :
142 0 : assert(u);
143 :
144 0 : exec = u->type == UNIT_SOCKET ? SOCKET(u)->control_command :
145 0 : u->type == UNIT_MOUNT ? MOUNT(u)->control_command :
146 0 : u->type == UNIT_SWAP ? SWAP(u)->control_command : NULL;
147 0 : k = verify_executable(u, exec);
148 0 : if (k < 0 && r == 0)
149 0 : r = k;
150 :
151 0 : if (u->type == UNIT_SERVICE)
152 0 : for (i = 0; i < ELEMENTSOF(SERVICE(u)->exec_command); i++) {
153 0 : k = verify_executable(u, SERVICE(u)->exec_command[i]);
154 0 : if (k < 0 && r == 0)
155 0 : r = k;
156 : }
157 :
158 0 : if (u->type == UNIT_SOCKET)
159 0 : for (i = 0; i < ELEMENTSOF(SOCKET(u)->exec_command); i++) {
160 0 : k = verify_executable(u, SOCKET(u)->exec_command[i]);
161 0 : if (k < 0 && r == 0)
162 0 : r = k;
163 : }
164 :
165 0 : return r;
166 : }
167 :
168 0 : static int verify_documentation(Unit *u, bool check_man) {
169 : char **p;
170 0 : int r = 0, k;
171 :
172 0 : STRV_FOREACH(p, u->documentation) {
173 0 : log_unit_debug(u, "Found documentation item: %s", *p);
174 :
175 0 : if (check_man && startswith(*p, "man:")) {
176 0 : k = show_man_page(*p + 4, true);
177 0 : if (k != 0) {
178 0 : if (k < 0)
179 0 : log_unit_error_errno(u, k, "Can't show %s: %m", *p + 4);
180 : else {
181 0 : log_unit_error(u, "Command 'man %s' failed with code %d", *p + 4, k);
182 0 : k = -ENOEXEC;
183 : }
184 0 : if (r == 0)
185 0 : r = k;
186 : }
187 : }
188 : }
189 :
190 : /* Check remote URLs? */
191 :
192 0 : return r;
193 : }
194 :
195 0 : static int verify_unit(Unit *u, bool check_man) {
196 0 : _cleanup_(sd_bus_error_free) sd_bus_error err = SD_BUS_ERROR_NULL;
197 : int r, k;
198 :
199 0 : assert(u);
200 :
201 0 : if (DEBUG_LOGGING)
202 0 : unit_dump(u, stdout, "\t");
203 :
204 0 : log_unit_debug(u, "Creating %s/start job", u->id);
205 0 : r = manager_add_job(u->manager, JOB_START, u, JOB_REPLACE, NULL, &err, NULL);
206 0 : if (r < 0)
207 0 : log_unit_error_errno(u, r, "Failed to create %s/start: %s", u->id, bus_error_message(&err, r));
208 :
209 0 : k = verify_socket(u);
210 0 : if (k < 0 && r == 0)
211 0 : r = k;
212 :
213 0 : k = verify_executables(u);
214 0 : if (k < 0 && r == 0)
215 0 : r = k;
216 :
217 0 : k = verify_documentation(u, check_man);
218 0 : if (k < 0 && r == 0)
219 0 : r = k;
220 :
221 0 : return r;
222 : }
223 :
224 0 : int verify_units(char **filenames, UnitFileScope scope, bool check_man, bool run_generators) {
225 0 : const ManagerTestRunFlags flags =
226 : MANAGER_TEST_RUN_BASIC |
227 0 : MANAGER_TEST_RUN_ENV_GENERATORS |
228 0 : run_generators * MANAGER_TEST_RUN_GENERATORS;
229 :
230 0 : _cleanup_(manager_freep) Manager *m = NULL;
231 0 : Unit *units[strv_length(filenames)];
232 0 : _cleanup_free_ char *var = NULL;
233 0 : int r = 0, k, i, count = 0;
234 : char **filename;
235 :
236 0 : if (strv_isempty(filenames))
237 0 : return 0;
238 :
239 : /* set the path */
240 0 : r = generate_path(&var, filenames);
241 0 : if (r < 0)
242 0 : return log_error_errno(r, "Failed to generate unit load path: %m");
243 :
244 0 : assert_se(set_unit_path(var) >= 0);
245 :
246 0 : r = manager_new(scope, flags, &m);
247 0 : if (r < 0)
248 0 : return log_error_errno(r, "Failed to initialize manager: %m");
249 :
250 0 : log_debug("Starting manager...");
251 :
252 0 : r = manager_startup(m, NULL, NULL);
253 0 : if (r < 0)
254 0 : return r;
255 :
256 0 : manager_clear_jobs(m);
257 :
258 0 : log_debug("Loading remaining units from the command line...");
259 :
260 0 : STRV_FOREACH(filename, filenames) {
261 0 : _cleanup_free_ char *prepared = NULL;
262 :
263 0 : log_debug("Handling %s...", *filename);
264 :
265 0 : k = prepare_filename(*filename, &prepared);
266 0 : if (k < 0) {
267 0 : log_error_errno(k, "Failed to prepare filename %s: %m", *filename);
268 0 : if (r == 0)
269 0 : r = k;
270 0 : continue;
271 : }
272 :
273 0 : k = manager_load_startable_unit_or_warn(m, NULL, prepared, &units[count]);
274 0 : if (k < 0 && r == 0)
275 0 : r = k;
276 : else
277 0 : count++;
278 : }
279 :
280 0 : for (i = 0; i < count; i++) {
281 0 : k = verify_unit(units[i], check_man);
282 0 : if (k < 0 && r == 0)
283 0 : r = k;
284 : }
285 :
286 0 : return r;
287 : }
|
