chiark / gitweb /
bus: don't skip interfaces in bus_message_map_properties_changed()
[elogind.git] / src / notify / notify.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 <stdio.h>
23 #include <getopt.h>
24 #include <error.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "systemd/sd-daemon.h"
31
32 #include "strv.h"
33 #include "util.h"
34 #include "log.h"
35 #include "sd-readahead.h"
36 #include "build.h"
37 #include "env-util.h"
38
39 static bool arg_ready = false;
40 static pid_t arg_pid = 0;
41 static const char *arg_status = NULL;
42 static bool arg_booted = false;
43 static const char *arg_readahead = NULL;
44
45 static void help(void) {
46         printf("%s [OPTIONS...] [VARIABLE=VALUE...]\n\n"
47                "Notify the init system about service status updates.\n\n"
48                "  -h --help             Show this help\n"
49                "     --version          Show package version\n"
50                "     --ready            Inform the init system about service start-up completion\n"
51                "     --pid[=PID]        Set main pid of daemon\n"
52                "     --status=TEXT      Set status text\n"
53                "     --booted           Returns 0 if the system was booted up with systemd, non-zero otherwise\n"
54                "     --readahead=ACTION Controls read-ahead operations\n",
55                program_invocation_short_name);
56 }
57
58 static int parse_argv(int argc, char *argv[]) {
59
60         enum {
61                 ARG_READY = 0x100,
62                 ARG_VERSION,
63                 ARG_PID,
64                 ARG_STATUS,
65                 ARG_BOOTED,
66                 ARG_READAHEAD
67         };
68
69         static const struct option options[] = {
70                 { "help",      no_argument,       NULL, 'h'           },
71                 { "version",   no_argument,       NULL, ARG_VERSION   },
72                 { "ready",     no_argument,       NULL, ARG_READY     },
73                 { "pid",       optional_argument, NULL, ARG_PID       },
74                 { "status",    required_argument, NULL, ARG_STATUS    },
75                 { "booted",    no_argument,       NULL, ARG_BOOTED    },
76                 { "readahead", required_argument, NULL, ARG_READAHEAD },
77                 {}
78         };
79
80         int c;
81
82         assert(argc >= 0);
83         assert(argv);
84
85         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) {
86
87                 switch (c) {
88
89                 case 'h':
90                         help();
91                         return 0;
92
93                 case ARG_VERSION:
94                         puts(PACKAGE_STRING);
95                         puts(SYSTEMD_FEATURES);
96                         return 0;
97
98                 case ARG_READY:
99                         arg_ready = true;
100                         break;
101
102                 case ARG_PID:
103
104                         if (optarg) {
105                                 if (parse_pid(optarg, &arg_pid) < 0) {
106                                         log_error("Failed to parse PID %s.", optarg);
107                                         return -EINVAL;
108                                 }
109                         } else
110                                 arg_pid = getppid();
111
112                         break;
113
114                 case ARG_STATUS:
115                         arg_status = optarg;
116                         break;
117
118                 case ARG_BOOTED:
119                         arg_booted = true;
120                         break;
121
122                 case ARG_READAHEAD:
123                         arg_readahead = optarg;
124                         break;
125
126                 case '?':
127                         return -EINVAL;
128
129                 default:
130                         assert_not_reached("Unhandled option");
131                 }
132         }
133
134         if (optind >= argc &&
135             !arg_ready &&
136             !arg_status &&
137             !arg_pid &&
138             !arg_booted &&
139             !arg_readahead) {
140                 help();
141                 return -EINVAL;
142         }
143
144         return 1;
145 }
146
147 int main(int argc, char* argv[]) {
148         _cleanup_free_ char *status = NULL, *cpid = NULL, *n = NULL;
149         _cleanup_strv_free_ char **final_env = NULL;
150         char* our_env[4];
151         unsigned i = 0;
152         int r;
153
154         log_parse_environment();
155         log_open();
156
157         r = parse_argv(argc, argv);
158         if (r <= 0)
159                 goto finish;
160
161         if (arg_booted)
162                 return sd_booted() <= 0;
163
164         if (arg_readahead) {
165                 r = sd_readahead(arg_readahead);
166                 if (r < 0) {
167                         log_error("Failed to issue read-ahead control command: %s", strerror(-r));
168                         goto finish;
169                 }
170         }
171
172         if (arg_ready)
173                 our_env[i++] = (char*) "READY=1";
174
175         if (arg_status) {
176                 status = strappend("STATUS=", arg_status);
177                 if (!status) {
178                         r = log_oom();
179                         goto finish;
180                 }
181
182                 our_env[i++] = status;
183         }
184
185         if (arg_pid > 0) {
186                 if (asprintf(&cpid, "MAINPID="PID_FMT, arg_pid) < 0) {
187                         r = log_oom();
188                         goto finish;
189                 }
190
191                 our_env[i++] = cpid;
192         }
193
194         our_env[i++] = NULL;
195
196         final_env = strv_env_merge(2, our_env, argv + optind);
197         if (!final_env) {
198                 r = log_oom();
199                 goto finish;
200         }
201
202         if (strv_length(final_env) <= 0) {
203                 r = 0;
204                 goto finish;
205         }
206
207         n = strv_join(final_env, "\n");
208         if (!n) {
209                 r = log_oom();
210                 goto finish;
211         }
212
213         r = sd_pid_notify(arg_pid, false, n);
214         if (r < 0) {
215                 log_error("Failed to notify init system: %s", strerror(-r));
216                 goto finish;
217         }
218
219         if (r == 0)
220                 r = -ENOTSUP;
221
222 finish:
223         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
224 }