load-service.cc 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972
  1. #include <algorithm>
  2. #include <string>
  3. #include <fstream>
  4. #include <locale>
  5. #include <limits>
  6. #include <list>
  7. #include <utility>
  8. #include <iterator>
  9. #include <cstring>
  10. #include <cstdlib>
  11. #include <sys/stat.h>
  12. #include <sys/types.h>
  13. #include <pwd.h>
  14. #include <grp.h>
  15. #include <dirent.h>
  16. #include "proc-service.h"
  17. #include "dinit-log.h"
  18. #include "dinit-util.h"
  19. #include "dinit-utmp.h"
  20. using string = std::string;
  21. using string_iterator = std::string::iterator;
  22. // Perform environment variable substitution on a command line, if specified.
  23. // line - the string storing the command and arguments
  24. // offsets - the [start,end) pair of offsets of the command and each argument within the string
  25. //
  26. static void do_env_subst(const char *setting_name, ha_string &line,
  27. std::list<std::pair<unsigned,unsigned>> &offsets,
  28. environment::env_map const &envmap)
  29. {
  30. using namespace dinit_load;
  31. std::string line_s = std::string(line.c_str(), line.length());
  32. value_var_subst(setting_name, line_s, offsets, resolve_env_var, envmap);
  33. line = line_s;
  34. }
  35. // Process a dependency directory - filenames contained within correspond to service names which
  36. // are loaded and added as a dependency of the given type. Expected use is with a directory
  37. // containing symbolic links to other service descriptions, but this isn't required.
  38. // Failure to read the directory contents, or to find a service listed within, is not considered
  39. // a fatal error.
  40. static void process_dep_dir(dirload_service_set &sset,
  41. const char *servicename,
  42. const string &service_filename,
  43. std::list<prelim_dep> &deplist, const std::string &depdirpath,
  44. dependency_type dep_type,
  45. const service_record *avoid_circular)
  46. {
  47. std::string depdir_fname = combine_paths(parent_path(service_filename), depdirpath.c_str());
  48. DIR *depdir = opendir(depdir_fname.c_str());
  49. if (depdir == nullptr) {
  50. log(loglevel_t::WARN, "Could not open dependency directory '", depdir_fname,
  51. "' for ", servicename, " service.");
  52. return;
  53. }
  54. errno = 0;
  55. dirent * dent = readdir(depdir);
  56. while (dent != nullptr) {
  57. char * name = dent->d_name;
  58. if (name[0] != '.') {
  59. try {
  60. service_record * sr = sset.load_service(name);
  61. deplist.emplace_back(sr, dep_type);
  62. }
  63. catch (service_not_found &) {
  64. log(loglevel_t::WARN, "Ignoring unresolved dependency '", name,
  65. "' in dependency directory '", depdirpath,
  66. "' for ", servicename, " service.");
  67. }
  68. }
  69. errno = 0; // errno may have changed in the meantime
  70. dent = readdir(depdir);
  71. }
  72. if (errno != 0) {
  73. log(loglevel_t::WARN, "Error reading dependency directory '", depdirpath,
  74. "' for ", servicename, " service.");
  75. }
  76. closedir(depdir);
  77. }
  78. service_record * dirload_service_set::load_service(const char * name, const service_record *avoid_circular)
  79. {
  80. return load_reload_service(name, nullptr, avoid_circular);
  81. }
  82. service_record * dirload_service_set::reload_service(service_record * service)
  83. {
  84. return load_reload_service(service->get_name().c_str(), service, service);
  85. }
  86. using service_dep_list = decltype(std::declval<dinit_load::service_settings_wrapper<prelim_dep>>().depends);
  87. // Check for dependency cycles for the specified service (orig) with the given set of dependencies. Report
  88. // any cycles as occurring in _report_svc_name_.
  89. static void check_cycle(service_dep_list &deps, service_record *orig, const std::string &report_svc_name)
  90. {
  91. linked_uo_set<service_record *> pending;
  92. for (auto &new_dep : deps) {
  93. if (new_dep.to == orig) {
  94. throw service_cyclic_dependency(report_svc_name);
  95. }
  96. pending.add_back(new_dep.to);
  97. }
  98. for (auto i = pending.begin(); i != pending.end(); ++i) {
  99. auto &dep_list = (*i)->get_dependencies();
  100. for (auto &dep : dep_list) {
  101. if (dep.get_to() == orig) {
  102. throw service_cyclic_dependency(report_svc_name);
  103. }
  104. pending.add_back(dep.get_to());
  105. }
  106. }
  107. }
  108. // Check for dependency cycles in "before" dependencies, _orig_ is where cycles will be identified.
  109. static void check_cycle(service_dep_list &deps, service_record *orig)
  110. {
  111. check_cycle(deps, orig, orig->get_name());
  112. }
  113. // Update the dependencies of the specified service atomically.
  114. // May fail with bad_alloc, service_cyclic_dependency.
  115. static void update_depenencies(service_record *service,
  116. dinit_load::service_settings_wrapper<prelim_dep> &settings,
  117. std::list<service_dep> &before_deps)
  118. {
  119. check_cycle(settings.depends, service);
  120. std::list<service_dep> &deps = service->get_dependencies();
  121. auto first_preexisting = deps.begin();
  122. auto &depts = service->get_dependents();
  123. auto first_pre_dept = depts.begin();
  124. try {
  125. // Insert all new dependents (from "before" relationships) before the first pre-existing dependent
  126. for (auto new_dept_i = before_deps.begin(); new_dept_i != before_deps.end(); ) {
  127. auto &new_dept = *new_dept_i;
  128. depts.insert(depts.begin(), &new_dept);
  129. // splice the dependency into the dependent:
  130. auto next_dept_i = std::next(new_dept_i);
  131. auto &from_deps = new_dept.get_from()->get_dependencies();
  132. from_deps.splice(from_deps.begin(), before_deps, new_dept_i);
  133. new_dept_i = next_dept_i;
  134. }
  135. // Insert all the new dependencies before the first pre-existing dependency
  136. for (auto i = settings.depends.begin(); i != settings.depends.end(); ) {
  137. auto &new_dep = *i;
  138. service->add_dep(new_dep.to, new_dep.dep_type, first_preexisting);
  139. i = settings.depends.erase(i);
  140. }
  141. }
  142. catch (...) {
  143. // remove "before" dependencies from dependents
  144. for (auto i = depts.begin(); i != first_pre_dept; ) {
  145. auto next_i = std::next(i);
  146. (*i)->get_from()->rm_dep(**i);
  147. i = next_i;
  148. }
  149. // remove the inserted dependencies
  150. for (auto i = deps.begin(); i != first_preexisting; ) {
  151. i = service->rm_dep(i);
  152. }
  153. // re-throw the exception
  154. throw;
  155. }
  156. // Now remove all pre-existing dependencies, except for "before" dependencies (which come from the
  157. // linked service and so must be retained)
  158. for( ; first_preexisting != deps.end(); ) {
  159. if (first_preexisting->dep_type != dependency_type::BEFORE) {
  160. first_preexisting = service->rm_dep(first_preexisting);
  161. }
  162. else {
  163. ++first_preexisting;
  164. }
  165. }
  166. // Also remove pre-existing "before" dependents (because they come from this service)
  167. for( ; first_pre_dept != depts.end(); ) {
  168. auto next_pre_dept = std::next(first_pre_dept);
  169. if ((*first_pre_dept)->dep_type == dependency_type::BEFORE) {
  170. (*first_pre_dept)->get_from()->rm_dep(**first_pre_dept);
  171. }
  172. first_pre_dept = next_pre_dept;
  173. }
  174. }
  175. // Update the command, and dependencies, of the specified service atomically.
  176. // May fail with bad_alloc, service_cyclic_dependency.
  177. static void update_command_and_dependencies(base_process_service *service,
  178. dinit_load::service_settings_wrapper<prelim_dep> &settings,
  179. std::list<service_dep> &before_deps)
  180. {
  181. // Get the current command parts
  182. ha_string orig_cmd; std::vector<const char *> orig_arg_parts;
  183. service->get_command(orig_cmd, orig_arg_parts);
  184. // Separate the new command parts and set
  185. std::vector<const char *> cmd_arg_parts = separate_args(settings.command, settings.command_offsets);
  186. service->set_command(std::move(settings.command), std::move(cmd_arg_parts));
  187. try {
  188. update_depenencies(service, settings, before_deps);
  189. }
  190. catch (...) {
  191. // restore original command
  192. service->set_command(std::move(orig_cmd), std::move(orig_arg_parts));
  193. // re-throw the exception
  194. throw;
  195. }
  196. }
  197. // Check that the provided settings are compatible / ok to be applied to the specified (already loaded)
  198. // service.
  199. // Returns: true if a new service record must be created, false otherwise
  200. static bool check_settings_for_reload(service_record *service,
  201. dinit_load::service_settings_wrapper<prelim_dep> &settings)
  202. {
  203. using namespace dinit_load;
  204. const std::string &name = service->get_name();
  205. // To begin, assume a new record is needed
  206. bool create_new_record = true;
  207. if (service->get_state() != service_state_t::STOPPED) {
  208. // Can not change type of a running service.
  209. if (settings.service_type != service->get_type()) {
  210. throw service_load_exc(name, "cannot change type of non-stopped service.");
  211. }
  212. // Can not alter a starting/stopping service, at least for now.
  213. if (service->get_state() != service_state_t::STARTED) {
  214. throw service_load_exc(name,
  215. "cannot alter settings for service which is currently starting/stopping.");
  216. }
  217. // Check validity of dependencies (if started, regular deps must be started)
  218. for (auto &new_dep : settings.depends) {
  219. if (new_dep.dep_type == dependency_type::REGULAR) {
  220. if (new_dep.to->get_state() != service_state_t::STARTED) {
  221. throw service_load_exc(name,
  222. std::string("cannot add non-started dependency '")
  223. + new_dep.to->get_name() + "'.");
  224. }
  225. }
  226. }
  227. // Cannot change certain flags
  228. auto current_flags = service->get_flags();
  229. if (current_flags.starts_on_console != settings.onstart_flags.starts_on_console
  230. || current_flags.shares_console != settings.onstart_flags.shares_console) {
  231. throw service_load_exc(name, "cannot change starts_on_console/"
  232. "shares_console flags for a running service.");
  233. }
  234. // Cannot change pid file
  235. if (service->get_type() == service_type_t::BGPROCESS) {
  236. auto *bgp_service = static_cast<bgproc_service *>(service);
  237. if (bgp_service->get_pid_file() != settings.pid_file) {
  238. throw service_load_exc(name, "cannot change pid_file for running service.");
  239. }
  240. }
  241. // Cannot change inittab_id/inittab_line
  242. #if USE_UTMPX
  243. if (service->get_type() == service_type_t::PROCESS) {
  244. auto *proc_service = static_cast<process_service *>(service);
  245. auto *svc_utmp_id = proc_service->get_utmp_id();
  246. auto *svc_utmp_ln = proc_service->get_utmp_line();
  247. if (strncmp(svc_utmp_id, settings.inittab_id, proc_service->get_utmp_id_size()) != 0
  248. || strncmp(svc_utmp_ln, settings.inittab_line,
  249. proc_service->get_utmp_line_size()) != 0) {
  250. throw service_load_exc(name, "cannot change inittab-id or inittab-line "
  251. "settings for running service.");
  252. }
  253. }
  254. #endif
  255. // Cannot change log type
  256. if (value(service->get_type()).is_in(service_type_t::PROCESS, service_type_t::BGPROCESS,
  257. service_type_t::SCRIPTED)) {
  258. base_process_service *bps = static_cast<base_process_service *>(service);
  259. if (bps->get_log_mode() != settings.log_type) {
  260. throw service_load_exc(name, "cannot change log-type for running service.");
  261. }
  262. }
  263. // Already started; we must replace settings on existing service record
  264. create_new_record = false;
  265. }
  266. else if (settings.service_type == service->get_type()) {
  267. // No need to create a new record if the type hasn't changed
  268. create_new_record = false;
  269. }
  270. return create_new_record;
  271. }
  272. service_record * dirload_service_set::load_reload_service(const char *name, service_record *reload_svc,
  273. const service_record *avoid_circular)
  274. {
  275. // Load a new service, or reload an already-loaded service.
  276. // For reload, we have the following problems:
  277. // - ideally want to allow changing service type, at least for stopped services. That implies creating
  278. // a new (replacement) service_record object, at least in cases where the type does change.
  279. // - dependencies may change (including addition of new dependencies which aren't yet loaded). We need
  280. // to prevent cyclic dependencies forming.
  281. // - We want atomicity. If any new settings are not valid/alterable, or if a cyclic dependency is
  282. // created, nothing should change.
  283. // - We need to either transfer handles referring to the old service (so that they refer to the new
  284. // service), or make them invalid. Or, we alter the original service without creating a new one
  285. // (which we can only do if the type doesn't change).
  286. // Approach:
  287. // - determine whether we need a new service record or can alter the existing one
  288. // (loading a new service always creates a new record; reload only creates a new record if the service
  289. // type changes, and otherwise just changes the existing record in-place).
  290. // - if loading a new service, a dummy record is created to enable easy cyclic dependency detection.
  291. // (In other cases cycles must be checked by walking the service graph).
  292. // The dummy is replaced with the real service once loading is complete (or is removed if it fails).
  293. // - process settings from the service file (into a service_settings_wrapper).
  294. // - check that the new settings are valid (for reload, if the service is running, check if the settings
  295. // can be altered).
  296. // - create the new record and install the new settings in it (or the existing record if not creating a
  297. // new record). If doing a reload, check for cycles at this point (there is no dummy record in this
  298. // case, so the quick cycle detection is not active).
  299. // - (if doing a reload, with a new record) move the dependents on the original record to the new record.
  300. //
  301. // "Before" dependencies require special handling, as a "before = " specified in a service actually creates
  302. // a dependency in the specified service on this service. Hence they always require explicit cycle checks
  303. // (the quick cycle detection method using a dummy service cannot be used). For reloads this is done early,
  304. // for new services it is done late (after the dummy has been removed).
  305. //
  306. // This is all an intricate dance. If failure occurs at any stage, we must restore the previous state.
  307. // Limitations:
  308. // - caller must check there are no handles (or only a single requesting handle) to the service before
  309. // calling
  310. // - cannot change the type of a non-stopped service
  311. using std::string;
  312. using std::ifstream;
  313. using std::ios;
  314. using std::ios_base;
  315. using std::locale;
  316. using std::isspace;
  317. using std::list;
  318. using std::pair;
  319. using namespace dinit_load;
  320. if (reload_svc == nullptr) {
  321. // First try and find an existing record...
  322. service_record *existing = find_service(string(name), true);
  323. if (existing != nullptr) {
  324. if (existing == avoid_circular || existing->check_is_loading()) {
  325. throw service_cyclic_dependency(name);
  326. }
  327. if (existing->get_type() != service_type_t::PLACEHOLDER) {
  328. return existing;
  329. }
  330. // If we found a placeholder, we proceed as for a reload:
  331. reload_svc = existing;
  332. }
  333. }
  334. service_record *rval = nullptr;
  335. service_record *dummy = nullptr;
  336. ifstream service_file;
  337. string service_filename;
  338. int fail_load_errno = 0;
  339. std::string fail_load_path;
  340. const char *sdir = nullptr;
  341. // Couldn't find one. Have to load it.
  342. for (auto &service_dir : service_dirs) {
  343. sdir = service_dir.get_dir();
  344. service_filename = sdir;
  345. if (*(service_filename.rbegin()) != '/') {
  346. service_filename += '/';
  347. }
  348. service_filename += name;
  349. service_file.open(service_filename.c_str(), ios::in);
  350. if (service_file) break;
  351. if (errno != ENOENT && fail_load_errno == 0) {
  352. fail_load_errno = errno;
  353. fail_load_path = std::move(service_filename);
  354. }
  355. }
  356. if (!service_file) {
  357. if (fail_load_errno == 0) {
  358. throw service_not_found(string(name));
  359. }
  360. else {
  361. throw service_load_error(name, std::move(fail_load_path), fail_load_errno);
  362. }
  363. }
  364. service_settings_wrapper<prelim_dep> settings;
  365. service_record *consumer_of_svc = nullptr;
  366. string line;
  367. // getline can set failbit if it reaches end-of-file, we don't want an exception in that case. There's
  368. // no good way to handle an I/O error however, so we'll have exceptions thrown on badbit:
  369. service_file.exceptions(ios::badbit);
  370. bool create_new_record = true;
  371. // any "before" "dependencies" that were loaded
  372. std::list<service_dep> before_deps;
  373. auto exception_cleanup = [&]() {
  374. // Must remove the dummy service record.
  375. if (dummy != nullptr) {
  376. remove_service(dummy);
  377. delete dummy;
  378. }
  379. if (create_new_record && rval != nullptr) {
  380. rval->prepare_for_unload();
  381. delete rval;
  382. }
  383. for (service_dep &before_dep : before_deps) {
  384. service_record *before_svc = before_dep.get_from();
  385. if (before_svc->get_type() == service_type_t::PLACEHOLDER) {
  386. if (before_svc->is_unrefd()) {
  387. remove_service(before_svc);
  388. delete before_svc;
  389. }
  390. }
  391. }
  392. // Remove any "after" placeholders that were created while loading but not successfully added as
  393. // dependencies on the new service (rval). (This requires that settings.depends has been cleared
  394. // of any dependencies that were successfully added).
  395. for (prelim_dep &dep : settings.depends) {
  396. if (dep.to->get_type() == service_type_t::PLACEHOLDER) {
  397. if (dep.dep_type == dependency_type::AFTER && dep.to->is_unrefd()) {
  398. remove_service(dep.to);
  399. }
  400. }
  401. }
  402. // Remove any placeholder consumed service.
  403. if (consumer_of_svc != nullptr) {
  404. if (consumer_of_svc->get_type() == service_type_t::PLACEHOLDER) {
  405. if (consumer_of_svc->is_unrefd()) {
  406. remove_service(consumer_of_svc);
  407. delete consumer_of_svc;
  408. }
  409. }
  410. }
  411. };
  412. if (reload_svc == nullptr) {
  413. // Add a placeholder record now to prevent infinite recursion in case of cyclic dependency.
  414. // We replace this with the real service later (or remove it if we find a configuration error).
  415. try {
  416. dummy = new service_record(this, string(name), service_record::LOADING_TAG);
  417. add_service(dummy);
  418. }
  419. catch (...) {
  420. delete dummy; // (no effect if dummy is null)
  421. dummy = nullptr;
  422. throw;
  423. }
  424. }
  425. try {
  426. process_service_file(name, service_file,
  427. [&](string &line, unsigned line_num, string &setting,
  428. string_iterator &i, string_iterator &end) -> void {
  429. auto process_dep_dir_n = [&](std::list<prelim_dep> &deplist, const std::string &waitsford,
  430. dependency_type dep_type) -> void {
  431. process_dep_dir(*this, name, service_filename, deplist, waitsford, dep_type, reload_svc);
  432. };
  433. auto load_service_n = [&](const string &dep_name) -> service_record * {
  434. try {
  435. return load_service(dep_name.c_str(), reload_svc);
  436. }
  437. catch (service_description_exc &sle) {
  438. log_service_load_failure(sle);
  439. throw service_load_exc(name, "could not load dependency.");
  440. }
  441. catch (service_load_exc &sle) {
  442. log(loglevel_t::ERROR, "Could not load service ", sle.service_name, ": ",
  443. sle.exc_description);
  444. throw service_load_exc(name, "could not load dependency.");
  445. }
  446. };
  447. process_service_line(settings, name, line, line_num, setting, i, end, load_service_n,
  448. process_dep_dir_n);
  449. });
  450. service_file.close();
  451. auto report_err = [&](const char *msg){
  452. throw service_load_exc(name, msg);
  453. };
  454. environment srv_env;
  455. // Fill user vars before reading env file
  456. if (settings.export_passwd_vars) {
  457. fill_environment_userinfo(settings.run_as_uid, name, srv_env);
  458. }
  459. // Set service name in environment if desired
  460. if (settings.export_service_name) {
  461. std::string envname = "DINIT_SERVICE=";
  462. envname += name;
  463. srv_env.set_var(std::move(envname));
  464. }
  465. // This mapping is temporary, for load substitutions. (The environment actually *may* change
  466. // after load, e.g. through dinitctl setenv, either from the outside or from within services,
  467. // and so we need to calculate a fresh mapping on each process invocation).
  468. environment::env_map srv_envmap;
  469. if (!settings.env_file.empty()) {
  470. try {
  471. read_env_file(settings.env_file.data(), false, srv_env, true, sdir);
  472. } catch (const std::system_error &se) {
  473. throw service_load_exc(name, std::string("could not load environment file: ") + se.what());
  474. }
  475. }
  476. srv_envmap = srv_env.build(main_env);
  477. settings.finalise(report_err, srv_envmap);
  478. auto service_type = settings.service_type;
  479. if (reload_svc != nullptr) {
  480. // Make sure settings are able to be changed/are compatible
  481. create_new_record = check_settings_for_reload(reload_svc, settings);
  482. // If service current has an output consumer, make sure new settings are compatible
  483. if (reload_svc->get_log_consumer() != nullptr) {
  484. if (!value(service_type).is_in(service_type_t::PROCESS, service_type_t::BGPROCESS,
  485. service_type_t::SCRIPTED)) {
  486. throw service_load_exc(name, "service has output consumer; service type must correspond "
  487. "to output-producing service (process, bgprocess, or scripted)");
  488. }
  489. if (settings.log_type != log_type_id::PIPE) {
  490. throw service_load_exc(name, "service has output consumer; log type must be set "
  491. "to 'pipe'");
  492. }
  493. }
  494. // We also don't allow a running service to change its consumed service. This is checked
  495. // shortly.
  496. }
  497. bool have_consumed_svc = !settings.consumer_of_name.empty();
  498. if (have_consumed_svc) {
  499. consumer_of_svc = find_service(settings.consumer_of_name.c_str(), true);
  500. }
  501. if (reload_svc != nullptr && reload_svc->get_state() != service_state_t::STOPPED) {
  502. if (value(service_type).is_in(service_type_t::PROCESS, service_type_t::BGPROCESS)) {
  503. // Since it is not stopped, reload_svc type must be same as service_type, or
  504. // check_settings_for_reload would have complained. So it's also either PROCESS or
  505. // BGPROCESS.
  506. auto *current_consumed = ((process_service *)reload_svc)->get_consumed();
  507. if (current_consumed != consumer_of_svc) {
  508. throw service_load_exc(name, "cannot change consumed service ('consumer-of') when not stopped");
  509. }
  510. }
  511. }
  512. // Note, we need to be very careful to handle exceptions properly and roll back any changes that
  513. // we've made before the exception occurred, including destroying any placeholder services that we
  514. // create, etc.
  515. if (have_consumed_svc) {
  516. if (consumer_of_svc == nullptr) {
  517. consumer_of_svc = new placeholder_service(this, settings.consumer_of_name);
  518. try {
  519. add_service(consumer_of_svc);
  520. }
  521. catch (...) {
  522. delete consumer_of_svc;
  523. consumer_of_svc = nullptr;
  524. throw;
  525. }
  526. }
  527. else {
  528. auto consumed_type = consumer_of_svc->get_type();
  529. if (!value(consumed_type).is_in(service_type_t::PROCESS, service_type_t::BGPROCESS,
  530. service_type_t::SCRIPTED, service_type_t::PLACEHOLDER)) {
  531. throw service_load_exc(name, "the 'consumer-of' setting specifies a service of a "
  532. "type that does not produce output");
  533. }
  534. if (consumed_type != service_type_t::PLACEHOLDER) {
  535. base_process_service *bps_consumed = static_cast<base_process_service *>(consumer_of_svc);
  536. if (bps_consumed->get_log_mode() != log_type_id::PIPE) {
  537. throw service_load_exc(name, "the 'consumer-of' setting specifies a service that "
  538. "does not log via a pipe ('log-type = pipe')");
  539. }
  540. }
  541. service_record *current_consumer = consumer_of_svc->get_log_consumer();
  542. if (current_consumer != nullptr && current_consumer != reload_svc) {
  543. throw service_load_exc(name, "the 'consumer-of' setting specifies a service that "
  544. "already has a consumer");
  545. }
  546. }
  547. }
  548. // If we have "after" constraints, load them now and treat them as regular dependencies. We need
  549. // to do this now, after the other dependents are loaded, because we might create a placeholder
  550. // instead (and we don't want to create a placeholder, have it added to the list of dependencies,
  551. // then load the same service as a real dependency shortly afterwards, which would replace the
  552. // placeholder but leave a dangling pointer to it in the list).
  553. for (const std::string &after_ent : settings.after_svcs) {
  554. service_record *after_svc;
  555. if (after_ent == name) throw service_cyclic_dependency(name);
  556. after_svc = find_service(after_ent.c_str(), true);
  557. if (after_svc != nullptr) {
  558. if (after_svc->check_is_loading()) {
  559. throw service_cyclic_dependency(name);
  560. }
  561. }
  562. if (after_svc == nullptr) {
  563. after_svc = new placeholder_service(this, after_ent);
  564. try {
  565. add_service(after_svc);
  566. }
  567. catch (...) {
  568. delete after_svc;
  569. throw;
  570. }
  571. }
  572. try {
  573. settings.depends.emplace_back(after_svc, dependency_type::AFTER);
  574. }
  575. catch (...) {
  576. if (after_svc->is_unrefd()) {
  577. remove_service(after_svc);
  578. delete after_svc;
  579. throw;
  580. }
  581. }
  582. }
  583. // if we have "before" constraints, check them now.
  584. for (const std::string &before_ent : settings.before_svcs) {
  585. service_record *before_svc;
  586. if (before_ent == name) throw service_cyclic_dependency(name);
  587. before_svc = find_service(before_ent.c_str(), true);
  588. if (before_svc != nullptr) {
  589. check_cycle(settings.depends, before_svc, name);
  590. }
  591. else {
  592. bool before_svc_added = false;
  593. try {
  594. before_svc = new placeholder_service(this, before_ent);
  595. add_service(before_svc);
  596. before_svc_added = true;
  597. }
  598. catch (...) {
  599. if (before_svc_added) remove_service(before_svc);
  600. delete before_svc;
  601. throw;
  602. }
  603. }
  604. before_deps.emplace_back(before_svc, reload_svc, dependency_type::BEFORE);
  605. // (note, we may need to adjust the to-service if we create a new service record object
  606. // - this will be done later)
  607. }
  608. if (service_type == service_type_t::PROCESS) {
  609. do_env_subst("command", settings.command, settings.command_offsets, srv_envmap);
  610. do_env_subst("stop-command", settings.stop_command, settings.stop_command_offsets, srv_envmap);
  611. std::vector<const char *> stop_arg_parts = separate_args(settings.stop_command, settings.stop_command_offsets);
  612. process_service *rvalps;
  613. if (create_new_record) {
  614. rvalps = new process_service(this, string(name), std::move(settings.command),
  615. settings.command_offsets, settings.depends);
  616. settings.depends.clear();
  617. if (reload_svc != nullptr) {
  618. check_cycle(settings.depends, reload_svc);
  619. }
  620. }
  621. else {
  622. rvalps = static_cast<process_service *>(reload_svc);
  623. update_command_and_dependencies(rvalps, settings, before_deps);
  624. }
  625. rval = rvalps;
  626. // All of the following should be noexcept or must perform rollback on exception
  627. rvalps->set_stop_command(std::move(settings.stop_command), std::move(stop_arg_parts));
  628. rvalps->set_working_dir(std::move(settings.working_dir), sdir);
  629. rvalps->set_env_file(std::move(settings.env_file));
  630. #if SUPPORT_CGROUPS
  631. rvalps->set_cgroup(std::move(settings.run_in_cgroup));
  632. #endif
  633. rvalps->set_rlimits(std::move(settings.rlimits));
  634. rvalps->set_restart_interval(settings.restart_interval, settings.max_restarts);
  635. rvalps->set_restart_delay(settings.restart_delay);
  636. rvalps->set_stop_timeout(settings.stop_timeout);
  637. rvalps->set_start_timeout(settings.start_timeout);
  638. rvalps->set_extra_termination_signal(settings.term_signal);
  639. rvalps->set_run_as_uid_gid(settings.run_as_uid, settings.run_as_gid);
  640. rvalps->set_notification_fd(settings.readiness_fd);
  641. rvalps->set_notification_var(std::move(settings.readiness_var));
  642. rvalps->set_logfile_details(std::move(settings.logfile), settings.logfile_perms,
  643. settings.logfile_uid, settings.logfile_gid);
  644. rvalps->set_log_buf_max(settings.max_log_buffer_sz);
  645. rvalps->set_log_mode(settings.log_type);
  646. #if USE_UTMPX
  647. rvalps->set_utmp_id(settings.inittab_id);
  648. rvalps->set_utmp_line(settings.inittab_line);
  649. #endif
  650. }
  651. else if (service_type == service_type_t::BGPROCESS) {
  652. do_env_subst("command", settings.command, settings.command_offsets, srv_envmap);
  653. do_env_subst("stop-command", settings.stop_command, settings.stop_command_offsets, srv_envmap);
  654. std::vector<const char *> stop_arg_parts = separate_args(settings.stop_command, settings.stop_command_offsets);
  655. bgproc_service *rvalps;
  656. if (create_new_record) {
  657. rvalps = new bgproc_service(this, string(name), std::move(settings.command),
  658. settings.command_offsets, settings.depends);
  659. settings.depends.clear();
  660. if (reload_svc != nullptr) {
  661. check_cycle(settings.depends, reload_svc);
  662. }
  663. }
  664. else {
  665. rvalps = static_cast<bgproc_service *>(reload_svc);
  666. update_command_and_dependencies(rvalps, settings, before_deps);
  667. }
  668. rval = rvalps;
  669. // All of the following should be noexcept or must perform rollback on exception
  670. rvalps->set_stop_command(std::move(settings.stop_command), std::move(stop_arg_parts));
  671. rvalps->set_working_dir(std::move(settings.working_dir), sdir);
  672. rvalps->set_env_file(std::move(settings.env_file));
  673. #if SUPPORT_CGROUPS
  674. rvalps->set_cgroup(std::move(settings.run_in_cgroup));
  675. #endif
  676. rvalps->set_rlimits(std::move(settings.rlimits));
  677. rvalps->set_pid_file(std::move(settings.pid_file));
  678. rvalps->set_restart_interval(settings.restart_interval, settings.max_restarts);
  679. rvalps->set_restart_delay(settings.restart_delay);
  680. rvalps->set_stop_timeout(settings.stop_timeout);
  681. rvalps->set_start_timeout(settings.start_timeout);
  682. rvalps->set_extra_termination_signal(settings.term_signal);
  683. rvalps->set_run_as_uid_gid(settings.run_as_uid, settings.run_as_gid);
  684. rvalps->set_logfile_details(std::move(settings.logfile), settings.logfile_perms,
  685. settings.logfile_uid, settings.logfile_gid);
  686. rvalps->set_log_buf_max(settings.max_log_buffer_sz);
  687. rvalps->set_log_mode(settings.log_type);
  688. settings.onstart_flags.runs_on_console = false;
  689. }
  690. else if (service_type == service_type_t::SCRIPTED) {
  691. do_env_subst("command", settings.command, settings.command_offsets, srv_envmap);
  692. do_env_subst("stop-command", settings.stop_command, settings.stop_command_offsets, srv_envmap);
  693. std::vector<const char *> stop_arg_parts = separate_args(settings.stop_command, settings.stop_command_offsets);
  694. scripted_service *rvalps;
  695. if (create_new_record) {
  696. rvalps = new scripted_service(this, string(name), std::move(settings.command),
  697. settings.command_offsets, settings.depends);
  698. settings.depends.clear();
  699. if (reload_svc != nullptr) {
  700. check_cycle(settings.depends, reload_svc);
  701. }
  702. }
  703. else {
  704. rvalps = static_cast<scripted_service *>(reload_svc);
  705. update_command_and_dependencies(rvalps, settings, before_deps);
  706. }
  707. rval = rvalps;
  708. // All of the following should be noexcept or must perform rollback on exception
  709. rvalps->set_stop_command(std::move(settings.stop_command), std::move(stop_arg_parts));
  710. rvalps->set_working_dir(std::move(settings.working_dir), sdir);
  711. rvalps->set_env_file(std::move(settings.env_file));
  712. #if SUPPORT_CGROUPS
  713. rvalps->set_cgroup(std::move(settings.run_in_cgroup));
  714. #endif
  715. rvalps->set_rlimits(std::move(settings.rlimits));
  716. rvalps->set_stop_timeout(settings.stop_timeout);
  717. rvalps->set_start_timeout(settings.start_timeout);
  718. rvalps->set_extra_termination_signal(settings.term_signal);
  719. rvalps->set_run_as_uid_gid(settings.run_as_uid, settings.run_as_gid);
  720. rvalps->set_logfile_details(std::move(settings.logfile), settings.logfile_perms,
  721. settings.logfile_uid, settings.logfile_gid);
  722. rvalps->set_log_buf_max(settings.max_log_buffer_sz);
  723. rvalps->set_log_mode(settings.log_type);
  724. }
  725. else {
  726. if (create_new_record) {
  727. if (service_type == service_type_t::INTERNAL) {
  728. rval = new service_record(this, string(name), service_type, settings.depends);
  729. }
  730. else {
  731. /* TRIGGERED */
  732. rval = new triggered_service(this, string(name), service_type, settings.depends);
  733. }
  734. settings.depends.clear();
  735. if (reload_svc != nullptr) {
  736. check_cycle(settings.depends, reload_svc);
  737. }
  738. }
  739. else {
  740. rval = reload_svc;
  741. update_depenencies(rval, settings, before_deps);
  742. }
  743. }
  744. rval->set_auto_restart(settings.auto_restart);
  745. rval->set_smooth_recovery(settings.smooth_recovery);
  746. rval->set_flags(settings.onstart_flags);
  747. rval->set_socket_details(std::move(settings.socket_path), settings.socket_perms,
  748. settings.socket_uid, settings.socket_gid);
  749. rval->set_chain_to(std::move(settings.chain_to_name));
  750. rval->set_environment(std::move(srv_env));
  751. if (create_new_record) {
  752. // switch dependencies on old record so that they refer to the new record
  753. // first link in all the (new) "before" dependents (one way at this stage):
  754. auto &dept_list = rval->get_dependents();
  755. unsigned added_dependents = 0;
  756. try {
  757. for (auto &dept : before_deps) {
  758. dept_list.push_back(&dept);
  759. ++added_dependents;
  760. }
  761. }
  762. catch (...) {
  763. // Undo, since the invalid state will cause issues when the new service is disposed of
  764. while (added_dependents > 0) {
  765. dept_list.pop_back();
  766. --added_dependents;
  767. }
  768. throw;
  769. }
  770. // --- Point of no return: mustn't fail from here ---
  771. // Splice in the new "before" dependencies
  772. auto i = before_deps.begin();
  773. decltype(i) j;
  774. while (i != before_deps.end()) {
  775. j = std::next(i);
  776. i->set_to(rval);
  777. auto &from_deps = i->get_from()->get_dependencies();
  778. from_deps.splice(from_deps.end(), before_deps, i);
  779. i = j;
  780. }
  781. // Which service are we replacing? (It's either the one that's being reloaded, or a dummy)
  782. service_record *orig_svc = (reload_svc != nullptr) ? reload_svc : dummy;
  783. // Complete dependency/dependent transfers.
  784. // Remove all "before" dependents from the original service (these were created by the
  785. // original service itself)
  786. auto &reload_depts = orig_svc->get_dependents();
  787. for (auto i = reload_depts.begin(); i != reload_depts.end(); ) {
  788. auto next_i = std::next(i);
  789. if ((*i)->dep_type == dependency_type::BEFORE) {
  790. service_record *before_svc = (*i)->get_from();
  791. before_svc->rm_dep(**i);
  792. if (before_svc->get_type() == service_type_t::PLACEHOLDER && before_svc->is_unrefd()) {
  793. remove_service(before_svc);
  794. delete before_svc;
  795. }
  796. }
  797. i = next_i;
  798. }
  799. // Transfer dependents from the original service record to the new record;
  800. // set links in all dependents on the original to point to the new service:
  801. auto first_new_before = dept_list.begin();
  802. dept_list.splice(first_new_before, reload_depts);
  803. for (auto &dept : dept_list) {
  804. dept->set_to(rval);
  805. }
  806. // Transfer all "before" dependencies (which are actually created by other services) to the
  807. // new service
  808. auto &dep_list_prev = orig_svc->get_dependencies();
  809. auto &dep_list = rval->get_dependencies();
  810. for (auto i = dep_list_prev.begin(); i != dep_list_prev.end(); ++i) {
  811. if (i->dep_type == dependency_type::BEFORE) {
  812. i->set_from(rval);
  813. dep_list.splice(dep_list.end(), dep_list_prev, i++);
  814. continue;
  815. }
  816. }
  817. // Transfer any open file descriptors for (log) output to new service record
  818. if (value(service_type).is_in(service_type_t::PROCESS, service_type_t::BGPROCESS, service_type_t::SCRIPTED)) {
  819. ((base_process_service *)rval)->set_output_pipe_fds(orig_svc->transfer_output_pipe());
  820. auto *orig_consumer = orig_svc->get_log_consumer();
  821. if (orig_consumer != nullptr) {
  822. orig_consumer->set_consumer_for(rval);
  823. }
  824. }
  825. // Remove dependent-link for all dependencies from the original:
  826. orig_svc->prepare_for_unload();
  827. // Remove consumer-for link from consumed service, if it's changing:
  828. if (value(orig_svc->get_type()).is_in(service_type_t::PROCESS, service_type_t::BGPROCESS)) {
  829. process_service *ps_orig = static_cast<process_service *>(orig_svc);
  830. auto *orig_consumed = ps_orig->get_consumed();
  831. if (orig_consumed != nullptr && orig_consumed != consumer_of_svc) {
  832. orig_consumed->set_log_consumer(nullptr);
  833. }
  834. }
  835. // Finally, replace the old service with the new one:
  836. auto iter = std::find(records.begin(), records.end(), orig_svc);
  837. *iter = rval;
  838. delete orig_svc;
  839. }
  840. // Mark as consumer for output of target service (if any)
  841. if (value(service_type).is_in(service_type_t::PROCESS, service_type_t::BGPROCESS)) {
  842. process_service *psvc = (process_service *)rval;
  843. psvc->set_consumer_for(consumer_of_svc);
  844. if (consumer_of_svc != nullptr) {
  845. consumer_of_svc->set_log_consumer(psvc);
  846. }
  847. }
  848. return rval;
  849. }
  850. catch (service_description_exc &setting_exc)
  851. {
  852. exception_cleanup();
  853. if (setting_exc.service_name.empty()) {
  854. setting_exc.service_name = name;
  855. }
  856. throw;
  857. }
  858. catch (std::system_error &sys_err)
  859. {
  860. exception_cleanup();
  861. // don't use sys_err.what() since libstdc++ sometimes includes class names (basic_filebuf):
  862. throw service_load_exc(name, sys_err.code().message());
  863. }
  864. catch (...) // (should only be std::bad_alloc or service_load_exc)
  865. {
  866. exception_cleanup();
  867. throw;
  868. }
  869. }