6 #include <system_error>
10 #include <sys/types.h>
12 #include <sys/socket.h>
18 #include "control-cmds.h"
19 #include "service-constants.h"
21 #include "dinit-client.h"
23 // dinitctl: utility to control the Dinit daemon, including starting and stopping of services.
25 // This utility communicates with the dinit daemon via a unix stream socket (/dev/initctl,
26 // or $HOME/.dinitctl).
28 static constexpr uint16_t min_cp_version = 1;
29 static constexpr uint16_t max_cp_version = 1;
33 static int issue_load_service(int socknum, const char *service_name, bool find_only = false);
34 static int check_load_reply(int socknum, cpbuffer_t &, handle_t *handle_p, service_state_t *state_p);
35 static int start_stop_service(int socknum, cpbuffer_t &, const char *service_name, command_t command,
36 bool do_pin, bool wait_for_service, bool verbose);
37 static int unpin_service(int socknum, cpbuffer_t &, const char *service_name, bool verbose);
38 static int unload_service(int socknum, cpbuffer_t &, const char *service_name);
39 static int list_services(int socknum, cpbuffer_t &);
40 static int shutdown_dinit(int soclknum, cpbuffer_t &);
41 static int add_remove_dependency(int socknum, cpbuffer_t &rbuffer, bool add, char *service_from,
42 char *service_to, dependency_type dep_type);
45 static const char * describeState(bool stopped)
47 return stopped ? "stopped" : "started";
50 static const char * describeVerb(bool stop)
52 return stop ? "stop" : "start";
55 enum class command_t {
71 int main(int argc, char **argv)
75 bool show_help = argc < 2;
76 char *service_name = nullptr;
77 char *to_service_name = nullptr;
78 dependency_type dep_type;
79 bool dep_type_set = false;
81 std::string control_socket_str;
82 const char * control_socket_path = nullptr;
85 bool sys_dinit = false; // communicate with system daemon
86 bool wait_for_service = true;
89 command_t command = command_t::NONE;
91 for (int i = 1; i < argc; i++) {
92 if (argv[i][0] == '-') {
93 if (strcmp(argv[i], "--help") == 0) {
97 else if (strcmp(argv[i], "--no-wait") == 0) {
98 wait_for_service = false;
100 else if (strcmp(argv[i], "--quiet") == 0) {
103 else if (strcmp(argv[i], "--system") == 0 || strcmp(argv[i], "-s") == 0) {
106 else if (strcmp(argv[i], "--pin") == 0) {
110 cerr << "dinitctl: unrecognized option: " << argv[i] << " (use --help for help)\n";
114 else if (command == command_t::NONE) {
115 if (strcmp(argv[i], "start") == 0) {
116 command = command_t::START_SERVICE;
118 else if (strcmp(argv[i], "wake") == 0) {
119 command = command_t::WAKE_SERVICE;
121 else if (strcmp(argv[i], "stop") == 0) {
122 command = command_t::STOP_SERVICE;
124 else if (strcmp(argv[i], "release") == 0) {
125 command = command_t::RELEASE_SERVICE;
127 else if (strcmp(argv[i], "unpin") == 0) {
128 command = command_t::UNPIN_SERVICE;
130 else if (strcmp(argv[i], "unload") == 0) {
131 command = command_t::UNLOAD_SERVICE;
133 else if (strcmp(argv[i], "list") == 0) {
134 command = command_t::LIST_SERVICES;
136 else if (strcmp(argv[i], "shutdown") == 0) {
137 command = command_t::SHUTDOWN;
139 else if (strcmp(argv[i], "add-dep") == 0) {
140 command = command_t::ADD_DEPENDENCY;
142 else if (strcmp(argv[i], "rm-dep") == 0) {
143 command = command_t::RM_DEPENDENCY;
146 cerr << "dinitctl: unrecognized command: " << argv[i] << " (use --help for help)\n";
151 // service name / other non-option
152 if (command == command_t::ADD_DEPENDENCY || command == command_t::RM_DEPENDENCY) {
153 if (! dep_type_set) {
154 if (strcmp(argv[i], "regular") == 0) {
155 dep_type = dependency_type::REGULAR;
157 else if (strcmp(argv[i], "milestone") == 0) {
158 dep_type = dependency_type::MILESTONE;
160 else if (strcmp(argv[i], "waits-for") == 0) {
161 dep_type = dependency_type::WAITS_FOR;
169 else if (service_name == nullptr) {
170 service_name = argv[i];
172 else if (to_service_name == nullptr) {
173 to_service_name = argv[i];
181 if (service_name != nullptr) {
185 service_name = argv[i];
186 // TODO support multiple services
191 bool no_service_cmd = (command == command_t::LIST_SERVICES || command == command_t::SHUTDOWN);
193 if (service_name != nullptr && no_service_cmd) {
197 if ((service_name == nullptr && ! no_service_cmd) || command == command_t::NONE) {
201 if ((command == command_t::ADD_DEPENDENCY || command == command_t::RM_DEPENDENCY)
202 && (! dep_type_set || service_name == nullptr || to_service_name == nullptr)) {
207 cout << "dinitctl: control Dinit services\n"
210 " dinitctl [options] start [options] <service-name>\n"
211 " dinitctl [options] stop [options] <service-name>\n"
212 " dinitctl [options] wake [options] <service-name>\n"
213 " dinitctl [options] release [options] <service-name>\n"
214 " dinitctl [options] unpin <service-name>\n"
215 " dinitctl unload <service-name>\n"
217 " dinitctl shutdown\n"
218 " dinitctl add-dep <type> <from-service> <to-service>\n"
219 " dinitctl rm-dep <type> <from-service> <to-service>\n"
221 "Note: An activated service continues running when its dependents stop.\n"
224 " -s, --system : control system daemon instead of user daemon\n"
225 " --quiet : suppress output (except errors)\n"
228 " --help : show this help\n"
229 " --no-wait : don't wait for service startup/shutdown to complete\n"
230 " --pin : pin the service in the requested state\n";
234 signal(SIGPIPE, SIG_IGN);
236 control_socket_path = "/dev/dinitctl";
238 // Locate control socket
240 char * userhome = getenv("HOME");
241 if (userhome == nullptr) {
242 struct passwd * pwuid_p = getpwuid(getuid());
243 if (pwuid_p != nullptr) {
244 userhome = pwuid_p->pw_dir;
248 if (userhome != nullptr) {
249 control_socket_str = userhome;
250 control_socket_str += "/.dinitctl";
251 control_socket_path = control_socket_str.c_str();
254 cerr << "Cannot locate user home directory (set HOME or check /etc/passwd file)" << endl;
259 int socknum = socket(AF_UNIX, SOCK_STREAM, 0);
261 perror("dinitctl: socket");
265 struct sockaddr_un * name;
266 uint sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen(control_socket_path) + 1;
267 name = (struct sockaddr_un *) malloc(sockaddr_size);
268 if (name == nullptr) {
269 cerr << "dinitctl: Out of memory" << endl;
273 name->sun_family = AF_UNIX;
274 strcpy(name->sun_path, control_socket_path);
276 int connr = connect(socknum, (struct sockaddr *) name, sockaddr_size);
278 perror("dinitctl: connect");
283 // Start by querying protocol version:
285 check_protocol_version(min_cp_version, max_cp_version, rbuffer, socknum);
287 if (command == command_t::UNPIN_SERVICE) {
288 return unpin_service(socknum, rbuffer, service_name, verbose);
290 else if (command == command_t::UNLOAD_SERVICE) {
291 return unload_service(socknum, rbuffer, service_name);
293 else if (command == command_t::LIST_SERVICES) {
294 return list_services(socknum, rbuffer);
296 else if (command == command_t::SHUTDOWN) {
297 return shutdown_dinit(socknum, rbuffer);
299 else if (command == command_t::ADD_DEPENDENCY || command == command_t::RM_DEPENDENCY) {
300 return add_remove_dependency(socknum, rbuffer, command == command_t::ADD_DEPENDENCY,
301 service_name, to_service_name, dep_type);
304 return start_stop_service(socknum, rbuffer, service_name, command, do_pin,
305 wait_for_service, verbose);
308 catch (cp_old_client_exception &e) {
309 std::cerr << "dinitctl: too old (server reports newer protocol version)" << std::endl;
312 catch (cp_old_server_exception &e) {
313 std::cerr << "dinitctl: server too old or protocol error" << std::endl;
316 catch (cp_read_exception &e) {
317 cerr << "dinitctl: control socket read failure or protocol error" << endl;
320 catch (cp_write_exception &e) {
321 cerr << "dinitctl: control socket write error: " << std::strerror(e.errcode) << endl;
326 // Extract/read a string of specified length from the buffer/socket. The string is consumed
328 static std::string read_string(int socknum, cpbuffer_t &rbuffer, uint32_t length)
330 int rb_len = rbuffer.get_length();
331 if (rb_len >= length) {
332 std::string r = rbuffer.extract_string(0, length);
333 rbuffer.consume(length);
337 std::string r = rbuffer.extract_string(0, rb_len);
338 uint32_t rlen = length - rb_len;
342 rbuffer.fill(socknum);
343 char *bptr = rbuffer.get_ptr(0);
344 clen = rbuffer.get_length();
345 clen = std::min(clen, rlen);
346 r.append(bptr, clen);
350 rbuffer.consume(clen);
355 // Start/stop a service
356 static int start_stop_service(int socknum, cpbuffer_t &rbuffer, const char *service_name,
357 command_t command, bool do_pin, bool wait_for_service, bool verbose)
361 bool do_stop = (command == command_t::STOP_SERVICE || command == command_t::RELEASE_SERVICE);
363 if (issue_load_service(socknum, service_name)) {
367 // Now we expect a reply:
369 wait_for_reply(rbuffer, socknum);
371 service_state_t state;
372 //service_state_t target_state;
375 if (check_load_reply(socknum, rbuffer, &handle, &state) != 0) {
379 service_state_t wanted_state = do_stop ? service_state_t::STOPPED : service_state_t::STARTED;
382 case command_t::STOP_SERVICE:
383 pcommand = DINIT_CP_STOPSERVICE;
385 case command_t::RELEASE_SERVICE:
386 pcommand = DINIT_CP_RELEASESERVICE;
388 case command_t::START_SERVICE:
389 pcommand = DINIT_CP_STARTSERVICE;
391 case command_t::WAKE_SERVICE:
392 pcommand = DINIT_CP_WAKESERVICE;
397 // Need to issue STOPSERVICE/STARTSERVICE
398 // We'll do this regardless of the current service state / target state, since issuing
399 // start/stop also sets or clears the "explicitly started" flag on the service.
401 char buf[2 + sizeof(handle)];
403 buf[1] = do_pin ? 1 : 0;
404 memcpy(buf + 2, &handle, sizeof(handle));
405 write_all_x(socknum, buf, 2 + sizeof(handle));
407 wait_for_reply(rbuffer, socknum);
408 if (rbuffer[0] == DINIT_RP_ALREADYSS) {
409 bool already = (state == wanted_state);
411 cout << "Service " << (already ? "(already) " : "")
412 << describeState(do_stop) << "." << endl;
414 return 0; // success!
416 if (rbuffer[0] != DINIT_RP_ACK) {
417 cerr << "dinitctl: Protocol error." << endl;
423 if (! wait_for_service) {
425 cout << "Issued " << describeVerb(do_stop) << " command successfully." << endl;
430 service_event_t completionEvent;
431 service_event_t cancelledEvent;
434 completionEvent = service_event_t::STOPPED;
435 cancelledEvent = service_event_t::STOPCANCELLED;
438 completionEvent = service_event_t::STARTED;
439 cancelledEvent = service_event_t::STARTCANCELLED;
442 // Wait until service started:
443 int r = rbuffer.fill_to(socknum, 2);
445 if (rbuffer[0] >= 100) {
446 int pktlen = (unsigned char) rbuffer[1];
447 fill_buffer_to(rbuffer, socknum, pktlen);
449 if (rbuffer[0] == DINIT_IP_SERVICEEVENT) {
451 rbuffer.extract((char *) &ev_handle, 2, sizeof(ev_handle));
452 service_event_t event = static_cast<service_event_t>(rbuffer[2 + sizeof(ev_handle)]);
453 if (ev_handle == handle) {
454 if (event == completionEvent) {
456 cout << "Service " << describeState(do_stop) << "." << endl;
460 else if (event == cancelledEvent) {
462 cout << "Service " << describeVerb(do_stop) << " cancelled." << endl;
466 else if (! do_stop && event == service_event_t::FAILEDSTART) {
468 cout << "Service failed to start." << endl;
475 rbuffer.consume(pktlen);
476 r = rbuffer.fill_to(socknum, 2);
479 // Not an information packet?
480 cerr << "dinitctl: protocol error" << endl;
486 perror("dinitctl: read");
489 cerr << "protocol error (connection closed by server)" << endl;
494 // Issue a "load service" command (DINIT_CP_LOADSERVICE), without waiting for
495 // a response. Returns 1 on failure (with error logged), 0 on success.
496 static int issue_load_service(int socknum, const char *service_name, bool find_only)
499 uint16_t sname_len = strlen(service_name);
500 int bufsize = 3 + sname_len;
502 std::unique_ptr<char[]> ubuf(new char[bufsize]);
503 auto buf = ubuf.get();
505 buf[0] = find_only ? DINIT_CP_FINDSERVICE : DINIT_CP_LOADSERVICE;
506 memcpy(buf + 1, &sname_len, 2);
507 memcpy(buf + 3, service_name, sname_len);
509 write_all_x(socknum, buf, bufsize);
514 // Check that a "load service" reply was received, and that the requested service was found.
515 static int check_load_reply(int socknum, cpbuffer_t &rbuffer, handle_t *handle_p, service_state_t *state_p)
519 if (rbuffer[0] == DINIT_RP_SERVICERECORD) {
520 fill_buffer_to(rbuffer, socknum, 2 + sizeof(*handle_p));
521 rbuffer.extract((char *) handle_p, 2, sizeof(*handle_p));
522 if (state_p) *state_p = static_cast<service_state_t>(rbuffer[1]);
523 //target_state = static_cast<service_state_t>(rbuffer[2 + sizeof(handle)]);
524 rbuffer.consume(3 + sizeof(*handle_p));
527 else if (rbuffer[0] == DINIT_RP_NOSERVICE) {
528 cerr << "dinitctl: failed to find/load service." << endl;
532 cerr << "dinitctl: protocol error." << endl;
537 static int unpin_service(int socknum, cpbuffer_t &rbuffer, const char *service_name, bool verbose)
542 if (issue_load_service(socknum, service_name) == 1) {
546 // Now we expect a reply:
548 wait_for_reply(rbuffer, socknum);
552 if (check_load_reply(socknum, rbuffer, &handle, nullptr) != 0) {
556 // Issue UNPIN command.
558 char buf[1 + sizeof(handle)];
559 buf[0] = DINIT_CP_UNPINSERVICE;
560 memcpy(buf + 1, &handle, sizeof(handle));
561 write_all_x(socknum, buf, 2 + sizeof(handle));
563 wait_for_reply(rbuffer, socknum);
564 if (rbuffer[0] != DINIT_RP_ACK) {
565 cerr << "dinitctl: protocol error." << endl;
572 cout << "Service unpinned." << endl;
577 static int unload_service(int socknum, cpbuffer_t &rbuffer, const char *service_name)
582 if (issue_load_service(socknum, service_name, true) == 1) {
586 // Now we expect a reply:
587 wait_for_reply(rbuffer, socknum);
591 if (rbuffer[0] == DINIT_RP_NOSERVICE) {
592 cerr << "dinitctl: service not loaded." << endl;
596 if (check_load_reply(socknum, rbuffer, &handle, nullptr) != 0) {
600 // Issue UNLOAD command.
602 char buf[1 + sizeof(handle)];
603 buf[0] = DINIT_CP_UNLOADSERVICE;
604 memcpy(buf + 1, &handle, sizeof(handle));
605 write_all_x(socknum, buf, 2 + sizeof(handle));
607 wait_for_reply(rbuffer, socknum);
608 if (rbuffer[0] == DINIT_RP_NAK) {
609 cerr << "dinitctl: Could not unload service; service not stopped, or is a dependency of "
610 "other service." << endl;
613 if (rbuffer[0] != DINIT_RP_ACK) {
614 cerr << "dinitctl: Protocol error." << endl;
620 cout << "Service unloaded." << endl;
624 static int list_services(int socknum, cpbuffer_t &rbuffer)
628 char cmdbuf[] = { (char)DINIT_CP_LISTSERVICES };
629 write_all_x(socknum, cmdbuf, 1);
631 wait_for_reply(rbuffer, socknum);
632 while (rbuffer[0] == DINIT_RP_SVCINFO) {
633 int hdrsize = 8 + std::max(sizeof(int), sizeof(pid_t));
634 fill_buffer_to(rbuffer, socknum, hdrsize);
635 int nameLen = rbuffer[1];
636 service_state_t current = static_cast<service_state_t>(rbuffer[2]);
637 service_state_t target = static_cast<service_state_t>(rbuffer[3]);
639 int console_flags = rbuffer[4];
640 bool has_console = (console_flags & 2) != 0;
641 bool waiting_console = (console_flags & 1) != 0;
642 bool was_skipped = (console_flags & 4) != 0;
644 stopped_reason_t stop_reason = static_cast<stopped_reason_t>(rbuffer[5]);
648 if (current != service_state_t::STOPPED) {
649 rbuffer.extract((char *)&service_pid, 8, sizeof(service_pid));
652 rbuffer.extract((char *)&exit_status, 8, sizeof(exit_status));
655 fill_buffer_to(rbuffer, socknum, nameLen + hdrsize);
657 char *name_ptr = rbuffer.get_ptr(hdrsize);
658 int clength = std::min(rbuffer.get_contiguous_length(name_ptr), nameLen);
660 string name = string(name_ptr, clength);
661 name.append(rbuffer.get_buf_base(), nameLen - clength);
665 cout << (target == service_state_t::STARTED ? "{" : " ");
666 if (current == service_state_t::STARTED) {
667 cout << (was_skipped ? "s" : "+");
672 cout << (target == service_state_t::STARTED ? "}" : " ");
674 if (current == service_state_t::STARTING) {
677 else if (current == service_state_t::STOPPING) {
684 cout << (target == service_state_t::STOPPED ? "{" : " ");
685 if (current == service_state_t::STOPPED) {
686 bool did_fail = false;
687 if (stop_reason == stopped_reason_t::TERMINATED) {
688 if (!WIFEXITED(exit_status) || WEXITSTATUS(exit_status) != 0) {
692 else did_fail = (stop_reason != stopped_reason_t::NORMAL);
694 cout << (did_fail ? "X" : "-");
699 cout << (target == service_state_t::STOPPED ? "}" : " ");
701 cout << "] " << name;
703 if (current != service_state_t::STOPPED && service_pid != -1) {
704 cout << " (pid: " << service_pid << ")";
707 if (current == service_state_t::STOPPED && stop_reason == stopped_reason_t::TERMINATED) {
708 if (WIFEXITED(exit_status)) {
709 cout << " (exit status: " << WEXITSTATUS(exit_status) << ")";
711 else if (WIFSIGNALED(exit_status)) {
712 cout << " (signal: " << WSTOPSIG(exit_status) << ")";
717 cout << " (has console)";
719 else if (waiting_console) {
720 cout << " (waiting for console)";
725 rbuffer.consume(hdrsize + nameLen);
726 wait_for_reply(rbuffer, socknum);
729 if (rbuffer[0] != DINIT_RP_LISTDONE) {
730 cerr << "dinitctl: Control socket protocol error" << endl;
737 static int add_remove_dependency(int socknum, cpbuffer_t &rbuffer, bool add, char *service_from,
738 char *service_to, dependency_type dep_type)
742 // First find the "from" service:
743 if (issue_load_service(socknum, service_from, false) == 1) {
747 wait_for_reply(rbuffer, socknum);
749 handle_t from_handle;
751 if (check_load_reply(socknum, rbuffer, &from_handle, nullptr) != 0) {
755 // Then find or load the "to" service:
756 if (issue_load_service(socknum, service_to, false) == 1) {
760 wait_for_reply(rbuffer, socknum);
764 if (check_load_reply(socknum, rbuffer, &to_handle, nullptr) != 0) {
768 constexpr int pktsize = 2 + sizeof(handle_t) * 2;
769 char cmdbuf[pktsize] = { add ? (char)DINIT_CP_ADD_DEP : (char)DINIT_CP_REM_DEP, (char)dep_type};
770 memcpy(cmdbuf + 2, &from_handle, sizeof(from_handle));
771 memcpy(cmdbuf + 2 + sizeof(from_handle), &to_handle, sizeof(to_handle));
772 write_all_x(socknum, cmdbuf, pktsize);
774 wait_for_reply(rbuffer, socknum);
777 if (rbuffer[0] == DINIT_RP_NAK) {
778 cerr << "dinitctl: Could not add dependency: circular dependency or wrong state" << endl;
781 if (rbuffer[0] != DINIT_RP_ACK) {
782 cerr << "dinitctl: Control socket protocol error" << endl;
789 static int shutdown_dinit(int socknum, cpbuffer_t &rbuffer)
791 // TODO support no-wait option.
795 constexpr int bufsize = 2;
798 buf[0] = DINIT_CP_SHUTDOWN;
799 buf[1] = static_cast<char>(shutdown_type_t::HALT);
801 write_all_x(socknum, buf, bufsize);
803 wait_for_reply(rbuffer, socknum);
805 if (rbuffer[0] != DINIT_RP_ACK) {
806 cerr << "dinitctl: Control socket protocol error" << endl;
810 // Now wait for rollback complete:
813 wait_for_info(rbuffer, socknum);
814 if (rbuffer[0] == DINIT_ROLLBACK_COMPLETED) {
819 catch (cp_read_exception &exc) {
820 // Dinit can terminate before replying: let's assume that happened.
821 // TODO: better check, possibly ensure that dinit actually sends rollback complete before