klishd.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616
  1. #define _GNU_SOURCE
  2. #include <stdlib.h>
  3. #include <stdint.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <assert.h>
  7. #include <signal.h>
  8. #include <syslog.h>
  9. #include <unistd.h>
  10. #include <errno.h>
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13. #include <fcntl.h>
  14. #include <sys/socket.h>
  15. #include <sys/un.h>
  16. #include <sys/fsuid.h>
  17. #include <sys/wait.h>
  18. #include <poll.h>
  19. #include <time.h>
  20. #include <faux/faux.h>
  21. #include <faux/str.h>
  22. #include <faux/argv.h>
  23. #include <faux/ini.h>
  24. #include <faux/log.h>
  25. #include <faux/sched.h>
  26. #include <faux/sysdb.h>
  27. #include <faux/net.h>
  28. #include <faux/list.h>
  29. #include <faux/conv.h>
  30. #include <faux/file.h>
  31. #include <faux/eloop.h>
  32. #include <faux/error.h>
  33. #include <klish/ktp.h>
  34. #include <klish/ktp_session.h>
  35. #include <klish/kscheme.h>
  36. #include <klish/ischeme.h>
  37. #include <klish/kcontext.h>
  38. #include <klish/ksession.h>
  39. #include <klish/ksession_parse.h>
  40. #include <klish/kdb.h>
  41. #include <klish/kpargv.h>
  42. #include "private.h"
  43. // Local static functions
  44. bool_t daemonize(const char *pidfile);
  45. bool_t kentry_entrys_is_empty(const kentry_t *entry);
  46. static int create_listen_unix_sock(const char *path);
  47. static kscheme_t *load_all_dbs(const char *dbs,
  48. faux_ini_t *global_config, faux_error_t *error);
  49. static bool_t clear_scheme(kscheme_t *scheme, faux_error_t *error);
  50. static void signal_handler_empty(int signo);
  51. // Main loop events
  52. static bool_t stop_loop_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  53. void *associated_data, void *user_data);
  54. static bool_t refresh_config_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  55. void *associated_data, void *user_data);
  56. static bool_t listen_socket_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  57. void *associated_data, void *user_data);
  58. static bool_t wait_for_child_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  59. void *associated_data, void *user_data);
  60. /** @brief Main function
  61. */
  62. int main(int argc, char **argv)
  63. {
  64. int retval = -1;
  65. struct options *opts = NULL;
  66. int pidfd = -1;
  67. int logoptions = 0;
  68. faux_eloop_t *eloop = NULL;
  69. int listen_unix_sock = -1;
  70. ktpd_session_t *ktpd_session = NULL;
  71. kscheme_t *scheme = NULL;
  72. faux_error_t *error = faux_error_new();
  73. faux_ini_t *config = NULL;
  74. int client_fd = -1;
  75. struct sigaction sig_act = {};
  76. sigset_t sig_set = {};
  77. // Parse command line options
  78. opts = opts_init();
  79. if (opts_parse(argc, argv, opts))
  80. goto err;
  81. // Initialize syslog
  82. logoptions = LOG_CONS;
  83. if (opts->foreground)
  84. logoptions |= LOG_PERROR;
  85. openlog(LOG_NAME, logoptions, opts->log_facility);
  86. if (!opts->verbose)
  87. setlogmask(LOG_UPTO(LOG_INFO));
  88. // Parse config file
  89. syslog(LOG_DEBUG, "Parse config file: %s\n", opts->cfgfile);
  90. if (!access(opts->cfgfile, R_OK)) {
  91. if (!(config = config_parse(opts->cfgfile, opts)))
  92. goto err;
  93. } else if (opts->cfgfile_userdefined) {
  94. // User defined config must be found
  95. fprintf(stderr, "Error: Can't find config file %s\n",
  96. opts->cfgfile);
  97. goto err;
  98. }
  99. // DEBUG: Show options
  100. opts_show(opts);
  101. syslog(LOG_INFO, "Start daemon.\n");
  102. // Fork the daemon if needed
  103. if (!opts->foreground && !daemonize(opts->pidfile))
  104. goto err;
  105. // Load scheme
  106. if (!(scheme = load_all_dbs(opts->dbs, config, error))) {
  107. fprintf(stderr, "Scheme errors:\n");
  108. goto err;
  109. }
  110. // Listen socket
  111. syslog(LOG_DEBUG, "Create listen UNIX socket: %s\n", opts->unix_socket_path);
  112. listen_unix_sock = create_listen_unix_sock(opts->unix_socket_path);
  113. if (listen_unix_sock < 0)
  114. goto err;
  115. syslog(LOG_DEBUG, "Listen socket %d", listen_unix_sock);
  116. // Event loop
  117. eloop = faux_eloop_new(NULL);
  118. // Signals
  119. faux_eloop_add_signal(eloop, SIGINT, stop_loop_ev, NULL);
  120. faux_eloop_add_signal(eloop, SIGTERM, stop_loop_ev, NULL);
  121. faux_eloop_add_signal(eloop, SIGQUIT, stop_loop_ev, NULL);
  122. faux_eloop_add_signal(eloop, SIGHUP, refresh_config_ev, opts);
  123. faux_eloop_add_signal(eloop, SIGCHLD, wait_for_child_ev, NULL);
  124. // Listen socket. Waiting for new connections
  125. faux_eloop_add_fd(eloop, listen_unix_sock, POLLIN,
  126. listen_socket_ev, &client_fd);
  127. // Scheduled events
  128. // faux_eloop_add_sched_once_delayed(eloop, &delayed, 1, sched_once, NULL);
  129. // faux_eloop_add_sched_periodic_delayed(eloop, 2, sched_periodic, NULL, &period, FAUX_SCHED_INFINITE);
  130. // Main loop
  131. faux_eloop_loop(eloop);
  132. faux_eloop_free(eloop);
  133. retval = 0;
  134. err: // For listen daemon
  135. // Print errors
  136. if (faux_error_len(error) > 0)
  137. faux_error_show(error);
  138. faux_error_free(error);
  139. // Close listen socket
  140. if (listen_unix_sock >= 0)
  141. close(listen_unix_sock);
  142. // Finish listen daemon if it's not forked service process.
  143. if (client_fd < 0) {
  144. // Free scheme
  145. clear_scheme(scheme, error);
  146. // Free command line options
  147. opts_free(opts);
  148. faux_ini_free(config);
  149. // Remove pidfile
  150. if (pidfd >= 0) {
  151. if (unlink(opts->pidfile) < 0) {
  152. syslog(LOG_ERR, "Can't remove pid-file %s: %s\n",
  153. opts->pidfile, strerror(errno));
  154. }
  155. }
  156. syslog(LOG_INFO, "Stop daemon.\n");
  157. return retval;
  158. }
  159. // ATTENTION: It's a forked service process
  160. retval = -1; // Pessimism for service process
  161. eloop = NULL;
  162. // Re-Initialize syslog
  163. openlog(LOG_SERVICE_NAME, logoptions, opts->log_facility);
  164. if (!opts->verbose)
  165. setlogmask(LOG_UPTO(LOG_INFO));
  166. // Create event loop
  167. eloop = faux_eloop_new(NULL);
  168. // Create KTP session
  169. // Function ktpd_session_new() will add new events to eloop itself.
  170. ktpd_session = ktpd_session_new(client_fd, scheme, NULL, eloop);
  171. if (!ktpd_session) {
  172. syslog(LOG_ERR, "Can't create KTPd session\n");
  173. goto err_client;
  174. }
  175. syslog(LOG_DEBUG, "New connection %d\n", client_fd);
  176. // Signals
  177. faux_eloop_add_signal(eloop, SIGINT, stop_loop_ev, NULL);
  178. faux_eloop_add_signal(eloop, SIGTERM, stop_loop_ev, NULL);
  179. faux_eloop_add_signal(eloop, SIGQUIT, stop_loop_ev, NULL);
  180. // Ignore SIGPIPE from client. Don't use SIG_IGN because it will be
  181. // inherited.
  182. sigemptyset(&sig_set);
  183. sig_act.sa_flags = 0;
  184. sig_act.sa_mask = sig_set;
  185. sig_act.sa_handler = &signal_handler_empty;
  186. sigaction(SIGPIPE, &sig_act, NULL);
  187. // Main service loop
  188. faux_eloop_loop(eloop);
  189. retval = 0;
  190. err_client:
  191. ktpd_session_free(ktpd_session);
  192. faux_eloop_free(eloop);
  193. syslog(LOG_DEBUG, "Close connection %d", client_fd);
  194. close(client_fd);
  195. // Free scheme
  196. clear_scheme(scheme, error);
  197. // Free command line options
  198. opts_free(opts);
  199. faux_ini_free(config);
  200. return retval;
  201. }
  202. bool_t daemonize(const char *pidfile)
  203. {
  204. // Daemonize
  205. syslog(LOG_DEBUG, "Daemonize\n");
  206. if (!faux_daemon(0, 0, pidfile, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) {
  207. syslog(LOG_ERR, "Can't daemonize\n");
  208. return BOOL_FALSE;
  209. }
  210. syslog(LOG_DEBUG, "PID file: %s\n", pidfile);
  211. return BOOL_TRUE;
  212. }
  213. static bool_t load_db(kscheme_t *scheme, const char *db_name,
  214. faux_ini_t *config, faux_error_t *error)
  215. {
  216. kdb_t *db = NULL;
  217. const char *sofile = NULL;
  218. assert(scheme);
  219. if (!scheme)
  220. return BOOL_FALSE;
  221. assert(db_name);
  222. if (!db_name)
  223. return BOOL_FALSE;
  224. // DB.libxml2.so = <so filename>
  225. if (config)
  226. sofile = faux_ini_find(config, "so");
  227. db = kdb_new(db_name, sofile);
  228. assert(db);
  229. if (!db) {
  230. faux_ini_free(config);
  231. return BOOL_FALSE;
  232. }
  233. // Now kdb owns config
  234. kdb_set_ini(db, config);
  235. kdb_set_error(db, error);
  236. // Load DB plugin
  237. if (!kdb_load_plugin(db)) {
  238. faux_error_sprintf(error,
  239. "DB \"%s\": Can't load DB plugin", db_name);
  240. kdb_free(db);
  241. return BOOL_FALSE;
  242. }
  243. // Check plugin API version
  244. if ((kdb_major(db) != KDB_MAJOR) ||
  245. (kdb_minor(db) != KDB_MINOR)) {
  246. faux_error_sprintf(error,
  247. "DB \"%s\": Plugin's API version is %u.%u, need %u.%u",
  248. db_name,
  249. kdb_major(db), kdb_minor(db),
  250. KDB_MAJOR, KDB_MINOR);
  251. kdb_free(db);
  252. return BOOL_FALSE;
  253. }
  254. // Init plugin
  255. if (kdb_has_init_fn(db) && !kdb_init(db)) {
  256. faux_error_sprintf(error,
  257. "DB \"%s\": Can't init DB plugin", db_name);
  258. kdb_free(db);
  259. return BOOL_FALSE;
  260. }
  261. // Load scheme
  262. if (!kdb_has_load_fn(db) || !kdb_load_scheme(db, scheme)) {
  263. faux_error_sprintf(error,
  264. "DB \"%s\": Can't load scheme from DB plugin", db_name);
  265. kdb_fini(db);
  266. kdb_free(db);
  267. return BOOL_FALSE;
  268. }
  269. // Fini plugin
  270. if (kdb_has_fini_fn(db) && !kdb_fini(db)) {
  271. faux_error_sprintf(error,
  272. "DB \"%s\": Can't fini DB plugin", db_name);
  273. kdb_free(db);
  274. return BOOL_FALSE;
  275. }
  276. kdb_free(db);
  277. return BOOL_TRUE;
  278. }
  279. static kscheme_t *load_all_dbs(const char *dbs,
  280. faux_ini_t *global_config, faux_error_t *error)
  281. {
  282. kscheme_t *scheme = NULL;
  283. faux_argv_t *dbs_argv = NULL;
  284. faux_argv_node_t *iter = NULL;
  285. const char *db_name = NULL;
  286. bool_t retcode = BOOL_TRUE;
  287. kcontext_t *context = NULL;
  288. assert(dbs);
  289. if (!dbs)
  290. return NULL;
  291. scheme = kscheme_new();
  292. assert(scheme);
  293. if (!scheme)
  294. return NULL;
  295. dbs_argv = faux_argv_new();
  296. assert(dbs_argv);
  297. if (!dbs_argv) {
  298. kscheme_free(scheme);
  299. return NULL;
  300. }
  301. if (faux_argv_parse(dbs_argv, dbs) <= 0) {
  302. kscheme_free(scheme);
  303. faux_argv_free(dbs_argv);
  304. return NULL;
  305. }
  306. // For each DB
  307. iter = faux_argv_iter(dbs_argv);
  308. while ((db_name = faux_argv_each(&iter))) {
  309. faux_ini_t *config = NULL; // Sub-config for current DB
  310. if (global_config) {
  311. char *prefix = NULL;
  312. prefix = faux_str_mcat(&prefix, "DB.", db_name, ".", NULL);
  313. config = faux_ini_extract_subini(global_config, prefix);
  314. faux_str_free(prefix);
  315. }
  316. if (!load_db(scheme, db_name, config, error))
  317. retcode = BOOL_FALSE;
  318. }
  319. faux_argv_free(dbs_argv);
  320. // Something went wrong while loading DBs
  321. if (!retcode) {
  322. kscheme_free(scheme);
  323. return NULL;
  324. }
  325. // Prepare scheme
  326. context = kcontext_new(KCONTEXT_TYPE_PLUGIN_INIT);
  327. kcontext_set_scheme(context, scheme);
  328. retcode = kscheme_prepare(scheme, context, error);
  329. kcontext_free(context);
  330. if (!retcode) {
  331. kscheme_free(scheme);
  332. faux_error_sprintf(error, "Scheme preparing errors.\n");
  333. return NULL;
  334. }
  335. // Debug
  336. /* {
  337. kdb_t *deploy_db = NULL;
  338. // Deploy (for testing purposes)
  339. deploy_db = kdb_new("ischeme", NULL);
  340. kdb_load_plugin(deploy_db);
  341. kdb_init(deploy_db);
  342. kdb_deploy_scheme(deploy_db, scheme);
  343. kdb_fini(deploy_db);
  344. kdb_free(deploy_db);
  345. }
  346. */
  347. return scheme;
  348. }
  349. static bool_t clear_scheme(kscheme_t *scheme, faux_error_t *error)
  350. {
  351. kcontext_t *context = NULL;
  352. if (!scheme)
  353. return BOOL_TRUE; // It's not an error
  354. context = kcontext_new(KCONTEXT_TYPE_PLUGIN_FINI);
  355. kcontext_set_scheme(context, scheme);
  356. kscheme_fini(scheme, context, error);
  357. kcontext_free(context);
  358. kscheme_free(scheme);
  359. return BOOL_TRUE;
  360. }
  361. /** @brief Create listen socket
  362. *
  363. * Previously removes old socket's file from filesystem. Note daemon must check
  364. * for already working daemon to don't duplicate.
  365. *
  366. * @param [in] path Socket path within filesystem.
  367. * @return Socket descriptor of < 0 on error.
  368. */
  369. static int create_listen_unix_sock(const char *path)
  370. {
  371. int sock = -1;
  372. int opt = 1;
  373. struct sockaddr_un laddr = {};
  374. assert(path);
  375. if (!path)
  376. return -1;
  377. if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
  378. syslog(LOG_ERR, "Can't create socket: %s\n", strerror(errno));
  379. goto err;
  380. }
  381. if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
  382. syslog(LOG_ERR, "Can't set socket options: %s\n", strerror(errno));
  383. goto err;
  384. }
  385. // Remove old (lost) socket's file
  386. unlink(path);
  387. laddr.sun_family = AF_UNIX;
  388. strncpy(laddr.sun_path, path, USOCK_PATH_MAX);
  389. laddr.sun_path[USOCK_PATH_MAX - 1] = '\0';
  390. if (bind(sock, (struct sockaddr *)&laddr, sizeof(laddr))) {
  391. syslog(LOG_ERR, "Can't bind socket %s: %s\n", path, strerror(errno));
  392. goto err;
  393. }
  394. if (listen(sock, 128)) {
  395. unlink(path);
  396. syslog(LOG_ERR, "Can't listen on socket %s: %s\n", path, strerror(errno));
  397. goto err;
  398. }
  399. return sock;
  400. err:
  401. if (sock >= 0)
  402. close(sock);
  403. return -1;
  404. }
  405. /** @brief Stop main event loop.
  406. */
  407. static bool_t stop_loop_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  408. void *associated_data, void *user_data)
  409. {
  410. // Happy compiler
  411. eloop = eloop;
  412. type = type;
  413. associated_data = associated_data;
  414. user_data = user_data;
  415. return BOOL_FALSE; // Stop Event Loop
  416. }
  417. /** @brief Wait for child processes (service processes).
  418. */
  419. static bool_t wait_for_child_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  420. void *associated_data, void *user_data)
  421. {
  422. int wstatus = 0;
  423. pid_t child_pid = -1;
  424. // Wait for any child process. Doesn't block.
  425. while ((child_pid = waitpid(-1, &wstatus, WNOHANG)) > 0) {
  426. if (WIFSIGNALED(wstatus)) {
  427. syslog(LOG_ERR, "Service process %d was terminated "
  428. "by signal: %d",
  429. child_pid, WTERMSIG(wstatus));
  430. } else {
  431. syslog(LOG_ERR, "Service process %d was terminated: %d",
  432. child_pid, WEXITSTATUS(wstatus));
  433. }
  434. }
  435. // Happy compiler
  436. eloop = eloop;
  437. type = type;
  438. associated_data = associated_data;
  439. user_data = user_data;
  440. return BOOL_TRUE;
  441. }
  442. /** @brief Re-read config file.
  443. *
  444. * This function can refresh klishd options but plugins (dbs for example) are
  445. * already inited and there is no way to re-init them on-the-fly.
  446. */
  447. static bool_t refresh_config_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  448. void *associated_data, void *user_data)
  449. {
  450. struct options *opts = (struct options *)user_data;
  451. faux_ini_t *ini = NULL;
  452. if (access(opts->cfgfile, R_OK) == 0) {
  453. syslog(LOG_DEBUG, "Re-reading config file \"%s\"\n", opts->cfgfile);
  454. if (!(ini = config_parse(opts->cfgfile, opts)))
  455. syslog(LOG_ERR, "Error while config file parsing.\n");
  456. } else if (opts->cfgfile_userdefined) {
  457. syslog(LOG_ERR, "Can't find config file \"%s\"\n", opts->cfgfile);
  458. }
  459. faux_ini_free(ini); // No way to use it later
  460. // Happy compiler
  461. eloop = eloop;
  462. type = type;
  463. associated_data = associated_data;
  464. return BOOL_TRUE;
  465. }
  466. /** @brief Event on listen socket. New remote client.
  467. */
  468. static bool_t listen_socket_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  469. void *associated_data, void *user_data)
  470. {
  471. int new_conn = -1;
  472. faux_eloop_info_fd_t *info = (faux_eloop_info_fd_t *)associated_data;
  473. pid_t child_pid = -1;
  474. assert(user_data);
  475. new_conn = accept(info->fd, NULL, NULL);
  476. if (new_conn < 0) {
  477. syslog(LOG_ERR, "Can't accept() new connection");
  478. return BOOL_TRUE;
  479. }
  480. // Fork new instance for newly connected client
  481. child_pid = fork();
  482. if (child_pid < 0) {
  483. close(new_conn);
  484. syslog(LOG_ERR, "Can't fork service process for client");
  485. return BOOL_TRUE;
  486. }
  487. // Parent
  488. if (child_pid > 0) {
  489. close(new_conn); // It's needed by child but not for parent
  490. syslog(LOG_ERR, "Service process for client was forked: %d",
  491. child_pid);
  492. return BOOL_TRUE;
  493. }
  494. // Child (forked service process)
  495. // Pass new ktpd_session to main programm
  496. *((int *)user_data) = new_conn;
  497. type = type; // Happy compiler
  498. eloop = eloop;
  499. // Return BOOL_FALSE to break listen parent loop. Child will create its
  500. // own loop then.
  501. return BOOL_FALSE;
  502. }
  503. static void signal_handler_empty(int signo)
  504. {
  505. signo = signo; // Happy compiler
  506. }