klishd.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643
  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/kdb.h>
  40. #include <klish/kpargv.h>
  41. #include "private.h"
  42. #include "sch.c"
  43. // Local static functions
  44. static int create_listen_unix_sock(const char *path);
  45. static bool_t load_all_dbs(kscheme_t *scheme, const char *dbs,
  46. faux_ini_t *global_config, faux_error_t *error);
  47. // Main loop events
  48. static bool_t stop_loop_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  49. void *associated_data, void *user_data);
  50. static bool_t refresh_config_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  51. void *associated_data, void *user_data);
  52. static bool_t client_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  53. void *associated_data, void *user_data);
  54. static bool_t listen_socket_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  55. void *associated_data, void *user_data);
  56. static bool_t sched_once(faux_eloop_t *eloop, faux_eloop_type_e type,
  57. void *associated_data, void *user_data);
  58. static bool_t sched_periodic(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_clients_t *clients = NULL;
  71. kscheme_t *scheme = NULL;
  72. ksession_t *session = NULL;
  73. faux_error_t *error = faux_error_new();
  74. faux_ini_t *config = NULL;
  75. struct timespec delayed = { .tv_sec = 10, .tv_nsec = 0 };
  76. struct timespec period = { .tv_sec = 3, .tv_nsec = 0 };
  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
  103. if (!opts->foreground) {
  104. // Daemonize
  105. syslog(LOG_DEBUG, "Daemonize\n");
  106. if (daemon(0, 0) < 0) {
  107. syslog(LOG_ERR, "Can't daemonize\n");
  108. goto err;
  109. }
  110. // Write pidfile
  111. syslog(LOG_DEBUG, "Write PID file: %s\n", opts->pidfile);
  112. if ((pidfd = open(opts->pidfile,
  113. O_WRONLY | O_CREAT | O_EXCL | O_TRUNC,
  114. S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0) {
  115. syslog(LOG_WARNING, "Can't open pidfile %s: %s\n",
  116. opts->pidfile, strerror(errno));
  117. } else {
  118. char str[20];
  119. snprintf(str, sizeof(str), "%u\n", getpid());
  120. str[sizeof(str) - 1] = '\0';
  121. if (write(pidfd, str, strlen(str)) < 0)
  122. syslog(LOG_WARNING, "Can't write to %s: %s\n",
  123. opts->pidfile, strerror(errno));
  124. close(pidfd);
  125. }
  126. }
  127. // Scheme
  128. scheme = kscheme_new();
  129. {
  130. kcontext_t *context = NULL;
  131. bool_t prepare_retcode = BOOL_FALSE;
  132. kdb_t *deploy_db = NULL;
  133. // Load scheme
  134. if (!load_all_dbs(scheme, opts->dbs, config, error)) {
  135. fprintf(stderr, "Scheme errors:\n");
  136. goto err;
  137. }
  138. // Prepare scheme
  139. context = kcontext_new(KCONTEXT_PLUGIN_INIT);
  140. prepare_retcode = kscheme_prepare(scheme, context, error);
  141. kcontext_free(context);
  142. if (!prepare_retcode) {
  143. fprintf(stderr, "Scheme preparing errors:\n");
  144. goto err;
  145. }
  146. // Deploy (for testing purposes)
  147. deploy_db = kdb_new("ischeme", NULL);
  148. kdb_load_plugin(deploy_db);
  149. kdb_init(deploy_db);
  150. // kdb_deploy_scheme(deploy_db, scheme);
  151. kdb_fini(deploy_db);
  152. kdb_free(deploy_db);
  153. }
  154. // Parsing
  155. {
  156. // const char *line = "cmd o4 m7 o2 e1";
  157. const char *line = "cmd o4 o4 o4 m3 o2 e1 ";
  158. kpargv_t *pargv = NULL;
  159. kpargv_pargs_node_t *p_iter = NULL;
  160. session = ksession_new(scheme, "/lowview");
  161. kpath_push(ksession_path(session), klevel_new(kscheme_find_entry_by_path(scheme, "/main")));
  162. pargv = ksession_parse_line(session, line, KPURPOSE_COMPLETION);
  163. if (pargv) {
  164. printf("Level: %lu, Command: %s, Line '%s': %s\n",
  165. kpargv_level(pargv),
  166. kpargv_command(pargv) ? kentry_name(kpargv_command(pargv)) : "<none>",
  167. line,
  168. kpargv_status_str(pargv));
  169. kparg_t *parg = NULL;
  170. p_iter = kpargv_pargs_iter(pargv);
  171. if (kpargv_pargs_len(pargv) > 0) {
  172. while ((parg = kpargv_pargs_each(&p_iter))) {
  173. printf("%s(%s) ", kparg_value(parg), kentry_name(kparg_entry(parg)));
  174. }
  175. printf("\n");
  176. }
  177. // Completions
  178. if (!kpargv_completions_is_empty(pargv)) {
  179. kentry_t *completion = NULL;
  180. kpargv_completions_node_t *citer = kpargv_completions_iter(pargv);
  181. printf("Completions (%s):\n", kpargv_last_arg(pargv));
  182. while ((completion = kpargv_completions_each(&citer)))
  183. printf("* %s\n", kentry_name(completion));
  184. }
  185. }
  186. kpargv_free(pargv);
  187. ksession_free(session);
  188. }
  189. goto err; // Test purposes
  190. // Listen socket
  191. syslog(LOG_DEBUG, "Create listen UNIX socket: %s\n", opts->unix_socket_path);
  192. listen_unix_sock = create_listen_unix_sock(opts->unix_socket_path);
  193. if (listen_unix_sock < 0)
  194. goto err;
  195. syslog(LOG_DEBUG, "Listen socket %d", listen_unix_sock);
  196. // Clients sessions DB
  197. clients = ktpd_clients_new();
  198. assert(clients);
  199. if (!clients)
  200. goto err;
  201. // Event loop
  202. eloop = faux_eloop_new(NULL);
  203. // Signals
  204. faux_eloop_add_signal(eloop, SIGINT, stop_loop_ev, NULL);
  205. faux_eloop_add_signal(eloop, SIGTERM, stop_loop_ev, NULL);
  206. faux_eloop_add_signal(eloop, SIGQUIT, stop_loop_ev, NULL);
  207. faux_eloop_add_signal(eloop, SIGHUP, refresh_config_ev, opts);
  208. // Listen socket. Waiting for new connections
  209. faux_eloop_add_fd(eloop, listen_unix_sock, POLLIN, listen_socket_ev, clients);
  210. // Scheduled events
  211. faux_eloop_add_sched_once_delayed(eloop, &delayed, 1, sched_once, NULL);
  212. faux_eloop_add_sched_periodic_delayed(eloop, 2, sched_periodic, NULL, &period, FAUX_SCHED_INFINITE);
  213. // Main loop
  214. faux_eloop_loop(eloop);
  215. faux_eloop_free(eloop);
  216. /*
  217. // Non-blocking wait for all children
  218. while ((pid = waitpid(-1, NULL, WNOHANG)) > 0) {
  219. syslog(LOG_DEBUG, "Exit child process %d\n", pid);
  220. }
  221. */
  222. retval = 0;
  223. err:
  224. syslog(LOG_DEBUG, "Cleanup.\n");
  225. ktpd_clients_free(clients);
  226. // Close listen socket
  227. if (listen_unix_sock >= 0)
  228. close(listen_unix_sock);
  229. // Remove pidfile
  230. if (pidfd >= 0) {
  231. if (unlink(opts->pidfile) < 0) {
  232. syslog(LOG_ERR, "Can't remove pid-file %s: %s\n",
  233. opts->pidfile, strerror(errno));
  234. }
  235. }
  236. // Free scheme
  237. if (scheme) {
  238. kcontext_t *context = kcontext_new(KCONTEXT_PLUGIN_FINI);
  239. kscheme_fini(scheme, context, error);
  240. kcontext_free(context);
  241. kscheme_free(scheme);
  242. }
  243. // Free command line options
  244. opts_free(opts);
  245. faux_ini_free(config);
  246. syslog(LOG_INFO, "Stop daemon.\n");
  247. if (faux_error_len(error) > 0)
  248. faux_error_show(error);
  249. faux_error_free(error);
  250. return retval;
  251. }
  252. static bool_t load_db(kscheme_t *scheme, const char *db_name,
  253. faux_ini_t *config, faux_error_t *error)
  254. {
  255. kdb_t *db = NULL;
  256. const char *sofile = NULL;
  257. assert(scheme);
  258. if (!scheme)
  259. return BOOL_FALSE;
  260. assert(db_name);
  261. if (!db_name)
  262. return BOOL_FALSE;
  263. // DB.libxml2.so = <so filename>
  264. if (config)
  265. sofile = faux_ini_find(config, "so");
  266. db = kdb_new(db_name, sofile);
  267. assert(db);
  268. if (!db)
  269. return BOOL_FALSE;
  270. kdb_set_ini(db, config);
  271. kdb_set_error(db, error);
  272. // Load DB plugin
  273. if (!kdb_load_plugin(db)) {
  274. faux_error_sprintf(error,
  275. "DB \"%s\": Can't load DB plugin", db_name);
  276. kdb_free(db);
  277. return BOOL_FALSE;
  278. }
  279. // Check plugin API version
  280. if ((kdb_major(db) != KDB_MAJOR) ||
  281. (kdb_minor(db) != KDB_MINOR)) {
  282. faux_error_sprintf(error,
  283. "DB \"%s\": Plugin's API version is %u.%u, need %u.%u",
  284. db_name,
  285. kdb_major(db), kdb_minor(db),
  286. KDB_MAJOR, KDB_MINOR);
  287. kdb_free(db);
  288. return BOOL_FALSE;
  289. }
  290. // Init plugin
  291. if (kdb_has_init_fn(db) && !kdb_init(db)) {
  292. faux_error_sprintf(error,
  293. "DB \"%s\": Can't init DB plugin", db_name);
  294. kdb_free(db);
  295. return BOOL_FALSE;
  296. }
  297. // Load scheme
  298. if (!kdb_has_load_fn(db) || !kdb_load_scheme(db, scheme)) {
  299. faux_error_sprintf(error,
  300. "DB \"%s\": Can't load scheme from DB plugin", db_name);
  301. kdb_fini(db);
  302. kdb_free(db);
  303. return BOOL_FALSE;
  304. }
  305. // Fini plugin
  306. if (kdb_has_fini_fn(db) && !kdb_fini(db)) {
  307. faux_error_sprintf(error,
  308. "DB \"%s\": Can't fini DB plugin", db_name);
  309. kdb_free(db);
  310. return BOOL_FALSE;
  311. }
  312. kdb_free(db);
  313. return BOOL_TRUE;
  314. }
  315. static bool_t load_all_dbs(kscheme_t *scheme, const char *dbs,
  316. faux_ini_t *global_config, faux_error_t *error)
  317. {
  318. faux_argv_t *dbs_argv = NULL;
  319. faux_argv_node_t *iter = NULL;
  320. const char *db_name = NULL;
  321. bool_t retcode = BOOL_TRUE;
  322. assert(scheme);
  323. if (!scheme)
  324. return BOOL_FALSE;
  325. assert(dbs);
  326. if (!dbs)
  327. return BOOL_FALSE;
  328. dbs_argv = faux_argv_new();
  329. assert(dbs_argv);
  330. if (!dbs_argv)
  331. return BOOL_FALSE;
  332. if (faux_argv_parse(dbs_argv, dbs) <= 0) {
  333. faux_argv_free(dbs_argv);
  334. return BOOL_FALSE;
  335. }
  336. // For each DB
  337. iter = faux_argv_iter(dbs_argv);
  338. while ((db_name = faux_argv_each(&iter))) {
  339. faux_ini_t *config = NULL; // Sub-config for current DB
  340. char *prefix = NULL;
  341. prefix = faux_str_mcat(&prefix, "DB.", db_name, ".", NULL);
  342. if (config)
  343. config = faux_ini_extract_subini(global_config, prefix);
  344. if (!load_db(scheme, db_name, config, error))
  345. retcode = BOOL_FALSE;
  346. faux_ini_free(config);
  347. faux_str_free(prefix);
  348. }
  349. faux_argv_free(dbs_argv);
  350. return retcode;
  351. }
  352. /** @brief Create listen socket
  353. *
  354. * Previously removes old socket's file from filesystem. Note daemon must check
  355. * for already working daemon to don't duplicate.
  356. *
  357. * @param [in] path Socket path within filesystem.
  358. * @return Socket descriptor of < 0 on error.
  359. */
  360. static int create_listen_unix_sock(const char *path)
  361. {
  362. int sock = -1;
  363. int opt = 1;
  364. struct sockaddr_un laddr = {};
  365. assert(path);
  366. if (!path)
  367. return -1;
  368. if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
  369. syslog(LOG_ERR, "Can't create socket: %s\n", strerror(errno));
  370. goto err;
  371. }
  372. if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
  373. syslog(LOG_ERR, "Can't set socket options: %s\n", strerror(errno));
  374. goto err;
  375. }
  376. // Remove old (lost) socket's file
  377. unlink(path);
  378. laddr.sun_family = AF_UNIX;
  379. strncpy(laddr.sun_path, path, USOCK_PATH_MAX);
  380. laddr.sun_path[USOCK_PATH_MAX - 1] = '\0';
  381. if (bind(sock, (struct sockaddr *)&laddr, sizeof(laddr))) {
  382. syslog(LOG_ERR, "Can't bind socket %s: %s\n", path, strerror(errno));
  383. goto err;
  384. }
  385. if (listen(sock, 128)) {
  386. unlink(path);
  387. syslog(LOG_ERR, "Can't listen on socket %s: %s\n", path, strerror(errno));
  388. goto err;
  389. }
  390. return sock;
  391. err:
  392. if (sock >= 0)
  393. close(sock);
  394. return -1;
  395. }
  396. /** @brief Stop main event loop.
  397. */
  398. static bool_t stop_loop_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  399. void *associated_data, void *user_data)
  400. {
  401. // Happy compiler
  402. eloop = eloop;
  403. type = type;
  404. associated_data = associated_data;
  405. user_data = user_data;
  406. return BOOL_FALSE; // Stop Event Loop
  407. }
  408. /** @brief Re-read config file.
  409. *
  410. * This function can refresh klishd options but plugins (dbs for example) are
  411. * already inited and there is no way to re-init them on-the-fly.
  412. */
  413. static bool_t refresh_config_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  414. void *associated_data, void *user_data)
  415. {
  416. struct options *opts = (struct options *)user_data;
  417. faux_ini_t *ini = NULL;
  418. if (access(opts->cfgfile, R_OK) == 0) {
  419. syslog(LOG_DEBUG, "Re-reading config file \"%s\"\n", opts->cfgfile);
  420. if (!(ini = config_parse(opts->cfgfile, opts)))
  421. syslog(LOG_ERR, "Error while config file parsing.\n");
  422. } else if (opts->cfgfile_userdefined) {
  423. syslog(LOG_ERR, "Can't find config file \"%s\"\n", opts->cfgfile);
  424. }
  425. faux_ini_free(ini); // No way to use it later
  426. // Happy compiler
  427. eloop = eloop;
  428. type = type;
  429. associated_data = associated_data;
  430. return BOOL_TRUE;
  431. }
  432. bool_t fd_stall_cb(ktpd_session_t *session, void *user_data)
  433. {
  434. faux_eloop_t *eloop = (faux_eloop_t *)user_data;
  435. assert(session);
  436. assert(eloop);
  437. faux_eloop_include_fd_event(eloop, ktpd_session_fd(session), POLLOUT);
  438. return BOOL_TRUE;
  439. }
  440. /** @brief Event on listen socket. New remote client.
  441. */
  442. static bool_t listen_socket_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  443. void *associated_data, void *user_data)
  444. {
  445. int new_conn = -1;
  446. faux_eloop_info_fd_t *info = (faux_eloop_info_fd_t *)associated_data;
  447. ktpd_clients_t *clients = (ktpd_clients_t *)user_data;
  448. ktpd_session_t *session = NULL;
  449. assert(clients);
  450. new_conn = accept(info->fd, NULL, NULL);
  451. if (new_conn < 0) {
  452. syslog(LOG_ERR, "Can't accept() new connection");
  453. return BOOL_TRUE;
  454. }
  455. session = ktpd_clients_add(clients, new_conn);
  456. if (!session) {
  457. syslog(LOG_ERR, "Duplicated client fd");
  458. close(new_conn);
  459. return BOOL_TRUE;
  460. }
  461. ktpd_session_set_stall_cb(session, fd_stall_cb, eloop);
  462. faux_eloop_add_fd(eloop, new_conn, POLLIN, client_ev, clients);
  463. syslog(LOG_DEBUG, "New connection %d", new_conn);
  464. type = type; // Happy compiler
  465. user_data = user_data; // Happy compiler
  466. return BOOL_TRUE;
  467. }
  468. static bool_t client_ev(faux_eloop_t *eloop, faux_eloop_type_e type,
  469. void *associated_data, void *user_data)
  470. {
  471. faux_eloop_info_fd_t *info = (faux_eloop_info_fd_t *)associated_data;
  472. ktpd_clients_t *clients = (ktpd_clients_t *)user_data;
  473. ktpd_session_t *session = NULL;
  474. assert(clients);
  475. // Find out session
  476. session = ktpd_clients_find(clients, info->fd);
  477. if (!session) { // Some strange case
  478. syslog(LOG_ERR, "Can't find client session for fd %d", info->fd);
  479. faux_eloop_del_fd(eloop, info->fd);
  480. close(info->fd);
  481. return BOOL_TRUE;
  482. }
  483. // Write data
  484. if (info->revents & POLLOUT) {
  485. faux_eloop_exclude_fd_event(eloop, info->fd, POLLOUT);
  486. if (!ktpd_session_async_out(session)) {
  487. // Someting went wrong
  488. faux_eloop_del_fd(eloop, info->fd);
  489. ktpd_clients_del(clients, info->fd);
  490. syslog(LOG_ERR, "Problem with async input");
  491. }
  492. }
  493. // Read data
  494. if (info->revents & POLLIN) {
  495. if (!ktpd_session_async_in(session)) {
  496. // Someting went wrong
  497. faux_eloop_del_fd(eloop, info->fd);
  498. ktpd_clients_del(clients, info->fd);
  499. syslog(LOG_ERR, "Problem with async input");
  500. }
  501. }
  502. // EOF
  503. if (info->revents & POLLHUP) {
  504. faux_eloop_del_fd(eloop, info->fd);
  505. ktpd_clients_del(clients, info->fd);
  506. syslog(LOG_DEBUG, "Close connection %d", info->fd);
  507. }
  508. type = type; // Happy compiler
  509. user_data = user_data; // Happy compiler
  510. return BOOL_TRUE;
  511. }
  512. static bool_t sched_once(faux_eloop_t *eloop, faux_eloop_type_e type,
  513. void *associated_data, void *user_data)
  514. {
  515. faux_eloop_info_sched_t *info = (faux_eloop_info_sched_t *)associated_data;
  516. printf("Once %d\n", info->ev_id);
  517. // Happy compiler
  518. eloop = eloop;
  519. type = type;
  520. associated_data = associated_data;
  521. user_data = user_data;
  522. return BOOL_TRUE;
  523. }
  524. static bool_t sched_periodic(faux_eloop_t *eloop, faux_eloop_type_e type,
  525. void *associated_data, void *user_data)
  526. {
  527. faux_eloop_info_sched_t *info = (faux_eloop_info_sched_t *)associated_data;
  528. printf("Periodic %d\n", info->ev_id);
  529. // Happy compiler
  530. eloop = eloop;
  531. type = type;
  532. associated_data = associated_data;
  533. user_data = user_data;
  534. return BOOL_TRUE;
  535. }