6 #include <system_error>
10 #include <sys/socket.h>
16 #include "control-cmds.h"
17 #include "service-constants.h"
19 #include "dinit-client.h"
21 // dinitctl: utility to control the Dinit daemon, including starting and stopping of services.
23 // This utility communicates with the dinit daemon via a unix stream socket (/dev/initctl, or $HOME/.dinitctl).
25 static constexpr uint16_t min_cp_version = 1;
26 static constexpr uint16_t max_cp_version = 1;
30 static int issue_load_service(int socknum, const char *service_name, bool find_only = false);
31 static int check_load_reply(int socknum, cpbuffer_t &, handle_t *handle_p, service_state_t *state_p);
32 static int start_stop_service(int socknum, cpbuffer_t &, const char *service_name, command_t command,
33 bool do_pin, bool wait_for_service, bool verbose);
34 static int unpin_service(int socknum, cpbuffer_t &, const char *service_name, bool verbose);
35 static int unload_service(int socknum, cpbuffer_t &, const char *service_name);
36 static int list_services(int socknum, cpbuffer_t &);
37 static int shutdown_dinit(int soclknum, cpbuffer_t &);
40 static const char * describeState(bool stopped)
42 return stopped ? "stopped" : "started";
45 static const char * describeVerb(bool stop)
47 return stop ? "stop" : "start";
50 enum class command_t {
64 int main(int argc, char **argv)
68 bool show_help = argc < 2;
69 char *service_name = nullptr;
71 std::string control_socket_str;
72 const char * control_socket_path = nullptr;
75 bool sys_dinit = false; // communicate with system daemon
76 bool wait_for_service = true;
79 command_t command = command_t::NONE;
81 for (int i = 1; i < argc; i++) {
82 if (argv[i][0] == '-') {
83 if (strcmp(argv[i], "--help") == 0) {
87 else if (strcmp(argv[i], "--no-wait") == 0) {
88 wait_for_service = false;
90 else if (strcmp(argv[i], "--quiet") == 0) {
93 else if (strcmp(argv[i], "--system") == 0 || strcmp(argv[i], "-s") == 0) {
96 else if (strcmp(argv[i], "--pin") == 0) {
103 else if (command == command_t::NONE) {
104 if (strcmp(argv[i], "start") == 0) {
105 command = command_t::START_SERVICE;
107 else if (strcmp(argv[i], "wake") == 0) {
108 command = command_t::WAKE_SERVICE;
110 else if (strcmp(argv[i], "stop") == 0) {
111 command = command_t::STOP_SERVICE;
113 else if (strcmp(argv[i], "release") == 0) {
114 command = command_t::RELEASE_SERVICE;
116 else if (strcmp(argv[i], "unpin") == 0) {
117 command = command_t::UNPIN_SERVICE;
119 else if (strcmp(argv[i], "unload") == 0) {
120 command = command_t::UNLOAD_SERVICE;
122 else if (strcmp(argv[i], "list") == 0) {
123 command = command_t::LIST_SERVICES;
125 else if (strcmp(argv[i], "shutdown") == 0) {
126 command = command_t::SHUTDOWN;
135 if (service_name != nullptr) {
139 service_name = argv[i];
140 // TODO support multiple services
144 bool no_service_cmd = (command == command_t::LIST_SERVICES || command == command_t::SHUTDOWN);
146 if (service_name != nullptr && no_service_cmd) {
150 if ((service_name == nullptr && ! no_service_cmd) || command == command_t::NONE) {
155 cout << "dinitctl: control Dinit services" << endl;
157 cout << "\nUsage:" << endl;
158 cout << " dinitctl [options] start [options] <service-name> : start and activate service" << endl;
159 cout << " dinitctl [options] stop [options] <service-name> : stop service and cancel explicit activation" << endl;
160 cout << " dinitctl [options] wake [options] <service-name> : start but do not mark activated" << endl;
161 cout << " dinitctl [options] release [options] <service-name> : release activation, stop if no dependents" << endl;
162 cout << " dinitctl [options] unpin <service-name> : un-pin the service (after a previous pin)" << endl;
163 cout << " dinitctl unload <service-name> : unload the service" << endl;
164 cout << " dinitctl list : list loaded services" << endl;
165 cout << " dinitctl shutdown : stop all services and terminate dinit" << endl;
167 cout << "\nNote: An activated service continues running when its dependents stop." << endl;
169 cout << "\nGeneral options:" << endl;
170 cout << " -s, --system : control system daemon instead of user daemon" << endl;
171 cout << " --quiet : suppress output (except errors)" << endl;
173 cout << "\nCommand options:" << endl;
174 cout << " --help : show this help" << endl;
175 cout << " --no-wait : don't wait for service startup/shutdown to complete" << endl;
176 cout << " --pin : pin the service in the requested (started/stopped) state" << endl;
180 signal(SIGPIPE, SIG_IGN);
182 control_socket_path = "/dev/dinitctl";
184 // Locate control socket
186 char * userhome = getenv("HOME");
187 if (userhome == nullptr) {
188 struct passwd * pwuid_p = getpwuid(getuid());
189 if (pwuid_p != nullptr) {
190 userhome = pwuid_p->pw_dir;
194 if (userhome != nullptr) {
195 control_socket_str = userhome;
196 control_socket_str += "/.dinitctl";
197 control_socket_path = control_socket_str.c_str();
200 cerr << "Cannot locate user home directory (set HOME or check /etc/passwd file)" << endl;
205 int socknum = socket(AF_UNIX, SOCK_STREAM, 0);
207 perror("dinitctl: socket");
211 struct sockaddr_un * name;
212 uint sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen(control_socket_path) + 1;
213 name = (struct sockaddr_un *) malloc(sockaddr_size);
214 if (name == nullptr) {
215 cerr << "dinitctl: Out of memory" << endl;
219 name->sun_family = AF_UNIX;
220 strcpy(name->sun_path, control_socket_path);
222 int connr = connect(socknum, (struct sockaddr *) name, sockaddr_size);
224 perror("dinitctl: connect");
229 // Start by querying protocol version:
231 check_protocol_version(min_cp_version, max_cp_version, rbuffer, socknum);
233 if (command == command_t::UNPIN_SERVICE) {
234 return unpin_service(socknum, rbuffer, service_name, verbose);
236 else if (command == command_t::UNLOAD_SERVICE) {
237 return unload_service(socknum, rbuffer, service_name);
239 else if (command == command_t::LIST_SERVICES) {
240 return list_services(socknum, rbuffer);
242 else if (command == command_t::SHUTDOWN) {
243 return shutdown_dinit(socknum, rbuffer);
246 return start_stop_service(socknum, rbuffer, service_name, command, do_pin,
247 wait_for_service, verbose);
250 catch (cp_old_client_exception &e) {
251 std::cerr << "dinitctl: too old (server reports newer protocol version)" << std::endl;
254 catch (cp_old_server_exception &e) {
255 std::cerr << "dinitctl: server too old or protocol error" << std::endl;
258 catch (cp_read_exception &e) {
259 cerr << "dinitctl: control socket read failure or protocol error" << endl;
262 catch (cp_write_exception &e) {
263 cerr << "dinitctl: control socket write error: " << std::strerror(e.errcode) << endl;
268 // Start/stop a service
269 static int start_stop_service(int socknum, cpbuffer_t &rbuffer, const char *service_name,
270 command_t command, bool do_pin, bool wait_for_service, bool verbose)
274 bool do_stop = (command == command_t::STOP_SERVICE || command == command_t::RELEASE_SERVICE);
276 if (issue_load_service(socknum, service_name)) {
280 // Now we expect a reply:
282 wait_for_reply(rbuffer, socknum);
284 service_state_t state;
285 //service_state_t target_state;
288 if (check_load_reply(socknum, rbuffer, &handle, &state) != 0) {
292 service_state_t wanted_state = do_stop ? service_state_t::STOPPED : service_state_t::STARTED;
295 case command_t::STOP_SERVICE:
296 pcommand = DINIT_CP_STOPSERVICE;
298 case command_t::RELEASE_SERVICE:
299 pcommand = DINIT_CP_RELEASESERVICE;
301 case command_t::START_SERVICE:
302 pcommand = DINIT_CP_STARTSERVICE;
304 case command_t::WAKE_SERVICE:
305 pcommand = DINIT_CP_WAKESERVICE;
310 // Need to issue STOPSERVICE/STARTSERVICE
311 // We'll do this regardless of the current service state / target state, since issuing
312 // start/stop also sets or clears the "explicitly started" flag on the service.
314 char buf[2 + sizeof(handle)];
316 buf[1] = do_pin ? 1 : 0;
317 memcpy(buf + 2, &handle, sizeof(handle));
318 write_all_x(socknum, buf, 2 + sizeof(handle));
320 wait_for_reply(rbuffer, socknum);
321 if (rbuffer[0] == DINIT_RP_ALREADYSS) {
322 bool already = (state == wanted_state);
324 cout << "Service " << (already ? "(already) " : "") << describeState(do_stop) << "." << endl;
326 return 0; // success!
328 if (rbuffer[0] != DINIT_RP_ACK) {
329 cerr << "dinitctl: Protocol error." << endl;
335 if (! wait_for_service) {
337 cout << "Issued " << describeVerb(do_stop) << " command successfully." << endl;
342 service_event_t completionEvent;
343 service_event_t cancelledEvent;
346 completionEvent = service_event_t::STOPPED;
347 cancelledEvent = service_event_t::STOPCANCELLED;
350 completionEvent = service_event_t::STARTED;
351 cancelledEvent = service_event_t::STARTCANCELLED;
354 // Wait until service started:
355 int r = rbuffer.fill_to(socknum, 2);
357 if (rbuffer[0] >= 100) {
358 int pktlen = (unsigned char) rbuffer[1];
359 fill_buffer_to(rbuffer, socknum, pktlen);
361 if (rbuffer[0] == DINIT_IP_SERVICEEVENT) {
363 rbuffer.extract((char *) &ev_handle, 2, sizeof(ev_handle));
364 service_event_t event = static_cast<service_event_t>(rbuffer[2 + sizeof(ev_handle)]);
365 if (ev_handle == handle) {
366 if (event == completionEvent) {
368 cout << "Service " << describeState(do_stop) << "." << endl;
372 else if (event == cancelledEvent) {
374 cout << "Service " << describeVerb(do_stop) << " cancelled." << endl;
378 else if (! do_stop && event == service_event_t::FAILEDSTART) {
380 cout << "Service failed to start." << endl;
387 rbuffer.consume(pktlen);
388 r = rbuffer.fill_to(socknum, 2);
391 // Not an information packet?
392 cerr << "dinitctl: protocol error" << endl;
398 perror("dinitctl: read");
401 cerr << "protocol error (connection closed by server)" << endl;
406 // Issue a "load service" command (DINIT_CP_LOADSERVICE), without waiting for
407 // a response. Returns 1 on failure (with error logged), 0 on success.
408 static int issue_load_service(int socknum, const char *service_name, bool find_only)
411 uint16_t sname_len = strlen(service_name);
412 int bufsize = 3 + sname_len;
414 std::unique_ptr<char[]> ubuf(new char[bufsize]);
415 auto buf = ubuf.get();
417 buf[0] = find_only ? DINIT_CP_FINDSERVICE : DINIT_CP_LOADSERVICE;
418 memcpy(buf + 1, &sname_len, 2);
419 memcpy(buf + 3, service_name, sname_len);
421 write_all_x(socknum, buf, bufsize);
426 // Check that a "load service" reply was received, and that the requested service was found.
427 static int check_load_reply(int socknum, cpbuffer_t &rbuffer, handle_t *handle_p, service_state_t *state_p)
431 if (rbuffer[0] == DINIT_RP_SERVICERECORD) {
432 fill_buffer_to(rbuffer, socknum, 2 + sizeof(*handle_p));
433 rbuffer.extract((char *) handle_p, 2, sizeof(*handle_p));
434 if (state_p) *state_p = static_cast<service_state_t>(rbuffer[1]);
435 //target_state = static_cast<service_state_t>(rbuffer[2 + sizeof(handle)]);
436 rbuffer.consume(3 + sizeof(*handle_p));
439 else if (rbuffer[0] == DINIT_RP_NOSERVICE) {
440 cerr << "dinitctl: failed to find/load service." << endl;
444 cerr << "dinitctl: protocol error." << endl;
449 static int unpin_service(int socknum, cpbuffer_t &rbuffer, const char *service_name, bool verbose)
454 if (issue_load_service(socknum, service_name) == 1) {
458 // Now we expect a reply:
460 wait_for_reply(rbuffer, socknum);
464 if (check_load_reply(socknum, rbuffer, &handle, nullptr) != 0) {
468 // Issue UNPIN command.
470 char buf[1 + sizeof(handle)];
471 buf[0] = DINIT_CP_UNPINSERVICE;
472 memcpy(buf + 1, &handle, sizeof(handle));
473 write_all_x(socknum, buf, 2 + sizeof(handle));
475 wait_for_reply(rbuffer, socknum);
476 if (rbuffer[0] != DINIT_RP_ACK) {
477 cerr << "dinitctl: protocol error." << endl;
484 cout << "Service unpinned." << endl;
489 static int unload_service(int socknum, cpbuffer_t &rbuffer, const char *service_name)
494 if (issue_load_service(socknum, service_name, true) == 1) {
498 // Now we expect a reply:
500 wait_for_reply(rbuffer, socknum);
504 if (check_load_reply(socknum, rbuffer, &handle, nullptr) != 0) {
508 // Issue UNLOAD command.
510 char buf[1 + sizeof(handle)];
511 buf[0] = DINIT_CP_UNLOADSERVICE;
512 memcpy(buf + 1, &handle, sizeof(handle));
513 write_all_x(socknum, buf, 2 + sizeof(handle));
515 wait_for_reply(rbuffer, socknum);
516 if (rbuffer[0] == DINIT_RP_NAK) {
517 cerr << "dinitctl: Could not unload service; service not stopped, or is a dependency of "
518 "other service." << endl;
521 if (rbuffer[0] != DINIT_RP_ACK) {
522 cerr << "dinitctl: Protocol error." << endl;
528 cout << "Service unloaded." << endl;
532 static int list_services(int socknum, cpbuffer_t &rbuffer)
536 char cmdbuf[] = { (char)DINIT_CP_LISTSERVICES };
537 write_all_x(socknum, cmdbuf, 1);
539 wait_for_reply(rbuffer, socknum);
540 while (rbuffer[0] == DINIT_RP_SVCINFO) {
541 int hdrsize = 8 + std::max(sizeof(int), sizeof(pid_t));
542 fill_buffer_to(rbuffer, socknum, hdrsize);
543 int nameLen = rbuffer[1];
544 service_state_t current = static_cast<service_state_t>(rbuffer[2]);
545 service_state_t target = static_cast<service_state_t>(rbuffer[3]);
547 int console_flags = rbuffer[4];
548 bool has_console = (console_flags & 2) != 0;
549 bool waiting_console = (console_flags & 1) != 0;
551 // stopped_reason_t stop_reason = static_cast<stopped_reason_t>(rbuffer[5]);
555 if (current != service_state_t::STOPPED) {
556 rbuffer.extract((char *)&service_pid, 8, sizeof(service_pid));
559 rbuffer.extract((char *)&exit_status, 8, sizeof(exit_status));
562 fill_buffer_to(rbuffer, socknum, nameLen + hdrsize);
564 char *name_ptr = rbuffer.get_ptr(hdrsize);
565 int clength = std::min(rbuffer.get_contiguous_length(name_ptr), nameLen);
567 string name = string(name_ptr, clength);
568 name.append(rbuffer.get_buf_base(), nameLen - clength);
572 cout << (target == service_state_t::STARTED ? "{" : " ");
573 cout << (current == service_state_t::STARTED ? "+" : " ");
574 cout << (target == service_state_t::STARTED ? "}" : " ");
576 if (current == service_state_t::STARTING) {
579 else if (current == service_state_t::STOPPING) {
586 cout << (target == service_state_t::STOPPED ? "{" : " ");
587 cout << (current == service_state_t::STOPPED ? "-" : " ");
588 cout << (target == service_state_t::STOPPED ? "}" : " ");
590 cout << "] " << name;
592 if (current != service_state_t::STOPPED && service_pid != -1) {
593 cout << " (pid: " << service_pid << ")";
597 cout << " (has console)";
599 else if (waiting_console) {
600 cout << " (waiting for console)";
605 rbuffer.consume(hdrsize + nameLen);
606 wait_for_reply(rbuffer, socknum);
609 if (rbuffer[0] != DINIT_RP_LISTDONE) {
610 cerr << "dinitctl: Control socket protocol error" << endl;
617 static int shutdown_dinit(int socknum, cpbuffer_t &rbuffer)
619 // TODO support no-wait option.
623 constexpr int bufsize = 2;
626 buf[0] = DINIT_CP_SHUTDOWN;
627 buf[1] = static_cast<char>(shutdown_type_t::HALT);
629 write_all_x(socknum, buf, bufsize);
631 wait_for_reply(rbuffer, socknum);
633 if (rbuffer[0] != DINIT_RP_ACK) {
634 cerr << "dinitctl: Control socket protocol error" << endl;
638 // Now wait for rollback complete:
641 wait_for_info(rbuffer, socknum);
642 if (rbuffer[0] == DINIT_ROLLBACK_COMPLETED) {
647 catch (cp_read_exception &exc) {
648 // Dinit can terminate before replying: let's assume that happened.
649 // TODO: better check, possibly ensure that dinit actually sends rollback complete before