chiark / gitweb /
udev: declare some symbols static
[elogind.git] / src / sysctl / sysctl.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <stdlib.h>
23 #include <stdbool.h>
24 #include <errno.h>
25 #include <string.h>
26 #include <stdio.h>
27 #include <limits.h>
28 #include <getopt.h>
29
30 #include "log.h"
31 #include "strv.h"
32 #include "util.h"
33 #include "strv.h"
34 #include "hashmap.h"
35 #include "path-util.h"
36 #include "conf-files.h"
37 #include "fileio.h"
38 #include "build.h"
39
40 static char **arg_prefixes = NULL;
41
42 static const char conf_file_dirs[] =
43         "/etc/sysctl.d\0"
44         "/run/sysctl.d\0"
45         "/usr/local/lib/sysctl.d\0"
46         "/usr/lib/sysctl.d\0"
47 #ifdef HAVE_SPLIT_USR
48         "/lib/sysctl.d\0"
49 #endif
50         ;
51
52 static char *normalize_sysctl(char *s) {
53         char *n;
54
55         for (n = s; *n; n++)
56                 if (*n == '.')
57                         *n = '/';
58
59         return s;
60 }
61
62 static int apply_sysctl(const char *property, const char *value) {
63         _cleanup_free_ char *p = NULL;
64         char *n;
65         int r = 0, k;
66
67         log_debug("Setting '%s' to '%s'", property, value);
68
69         p = new(char, sizeof("/proc/sys/") + strlen(property));
70         if (!p)
71                 return log_oom();
72
73         n = stpcpy(p, "/proc/sys/");
74         strcpy(n, property);
75
76         if (!strv_isempty(arg_prefixes)) {
77                 char **i;
78                 bool good = false;
79
80                 STRV_FOREACH(i, arg_prefixes)
81                         if (path_startswith(p, *i)) {
82                                 good = true;
83                                 break;
84                         }
85
86                 if (!good) {
87                         log_debug("Skipping %s", p);
88                         return 0;
89                 }
90         }
91
92         k = write_string_file(p, value);
93         if (k < 0) {
94                 log_full(k == -ENOENT ? LOG_DEBUG : LOG_WARNING,
95                          "Failed to write '%s' to '%s': %s", value, p, strerror(-k));
96
97                 if (k != -ENOENT && r == 0)
98                         r = k;
99         }
100
101         return r;
102 }
103
104 static int apply_all(Hashmap *sysctl_options) {
105         int r = 0;
106         char *property, *value;
107         Iterator i;
108
109         assert(sysctl_options);
110
111         HASHMAP_FOREACH_KEY(value, property, sysctl_options, i) {
112                 int k;
113
114                 k = apply_sysctl(property, value);
115                 if (k < 0 && r == 0)
116                         r = k;
117         }
118         return r;
119 }
120
121 static int parse_file(Hashmap *sysctl_options, const char *path, bool ignore_enoent) {
122         _cleanup_fclose_ FILE *f = NULL;
123         int r;
124
125         assert(path);
126
127         r = search_and_fopen_nulstr(path, "re", conf_file_dirs, &f);
128         if (r < 0) {
129                 if (ignore_enoent && r == -ENOENT)
130                         return 0;
131
132                 log_error("Failed to open file '%s', ignoring: %s", path, strerror(-r));
133                 return r;
134         }
135
136         log_debug("parse: %s\n", path);
137         while (!feof(f)) {
138                 char l[LINE_MAX], *p, *value, *new_value, *property, *existing;
139                 void *v;
140                 int k;
141
142                 if (!fgets(l, sizeof(l), f)) {
143                         if (feof(f))
144                                 break;
145
146                         log_error("Failed to read file '%s', ignoring: %m", path);
147                         return -errno;
148                 }
149
150                 p = strstrip(l);
151                 if (!*p)
152                         continue;
153
154                 if (strchr(COMMENTS "\n", *p))
155                         continue;
156
157                 value = strchr(p, '=');
158                 if (!value) {
159                         log_error("Line is not an assignment in file '%s': %s", path, value);
160
161                         if (r == 0)
162                                 r = -EINVAL;
163                         continue;
164                 }
165
166                 *value = 0;
167                 value++;
168
169                 p = normalize_sysctl(strstrip(p));
170                 value = strstrip(value);
171
172                 existing = hashmap_get2(sysctl_options, p, &v);
173                 if (existing) {
174                         if (streq(value, existing))
175                                 continue;
176
177                         log_info("Overwriting earlier assignment of %s in file '%s'.", p, path);
178                         free(hashmap_remove(sysctl_options, p));
179                         free(v);
180                 }
181
182                 property = strdup(p);
183                 if (!property)
184                         return log_oom();
185
186                 new_value = strdup(value);
187                 if (!new_value) {
188                         free(property);
189                         return log_oom();
190                 }
191
192                 k = hashmap_put(sysctl_options, property, new_value);
193                 if (k < 0) {
194                         log_error("Failed to add sysctl variable %s to hashmap: %s", property, strerror(-k));
195                         free(property);
196                         free(new_value);
197                         return k;
198                 }
199         }
200
201         return r;
202 }
203
204 static int help(void) {
205
206         printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
207                "Applies kernel sysctl settings.\n\n"
208                "  -h --help             Show this help\n"
209                "     --version          Show package version\n"
210                "     --prefix=PATH      Only apply rules that apply to paths with the specified prefix\n",
211                program_invocation_short_name);
212
213         return 0;
214 }
215
216 static int parse_argv(int argc, char *argv[]) {
217
218         enum {
219                 ARG_VERSION = 0x100,
220                 ARG_PREFIX
221         };
222
223         static const struct option options[] = {
224                 { "help",      no_argument,       NULL, 'h'           },
225                 { "version",   no_argument,       NULL, ARG_VERSION   },
226                 { "prefix",    required_argument, NULL, ARG_PREFIX    },
227                 {}
228         };
229
230         int c;
231
232         assert(argc >= 0);
233         assert(argv);
234
235         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) {
236
237                 switch (c) {
238
239                 case 'h':
240                         return help();
241
242                 case ARG_VERSION:
243                         puts(PACKAGE_STRING);
244                         puts(SYSTEMD_FEATURES);
245                         return 0;
246
247                 case ARG_PREFIX: {
248                         char *p;
249                         char **l;
250
251                         for (p = optarg; *p; p++)
252                                 if (*p == '.')
253                                         *p = '/';
254
255                         l = strv_append(arg_prefixes, optarg);
256                         if (!l)
257                                 return log_oom();
258
259                         strv_free(arg_prefixes);
260                         arg_prefixes = l;
261
262                         break;
263                 }
264
265                 case '?':
266                         return -EINVAL;
267
268                 default:
269                         assert_not_reached("Unhandled option");
270                 }
271         }
272
273         return 1;
274 }
275
276 int main(int argc, char *argv[]) {
277         int r = 0, k;
278         Hashmap *sysctl_options;
279
280         r = parse_argv(argc, argv);
281         if (r <= 0)
282                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
283
284         log_set_target(LOG_TARGET_AUTO);
285         log_parse_environment();
286         log_open();
287
288         umask(0022);
289
290         sysctl_options = hashmap_new(string_hash_func, string_compare_func);
291         if (!sysctl_options) {
292                 r = log_oom();
293                 goto finish;
294         }
295
296         r = 0;
297
298         if (argc > optind) {
299                 int i;
300
301                 for (i = optind; i < argc; i++) {
302                         k = parse_file(sysctl_options, argv[i], false);
303                         if (k < 0 && r == 0)
304                                 r = k;
305                 }
306         } else {
307                 _cleanup_strv_free_ char **files = NULL;
308                 char **f;
309
310                 r = conf_files_list_nulstr(&files, ".conf", NULL, conf_file_dirs);
311                 if (r < 0) {
312                         log_error("Failed to enumerate sysctl.d files: %s", strerror(-r));
313                         goto finish;
314                 }
315
316                 STRV_FOREACH(f, files) {
317                         k = parse_file(sysctl_options, *f, true);
318                         if (k < 0 && r == 0)
319                                 r = k;
320                 }
321         }
322
323         k = apply_all(sysctl_options);
324         if (k < 0 && r == 0)
325                 r = k;
326
327 finish:
328         hashmap_free_free_free(sysctl_options);
329         strv_free(arg_prefixes);
330
331         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
332 }