![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / sysdep / unix|
Return to main.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / sysdep / unix |
1.1 misho 1: /*
2: * BIRD Internet Routing Daemon -- Unix Entry Point
3: *
4: * (c) 1998--2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: #undef LOCAL_DEBUG
10:
11: #ifndef _GNU_SOURCE
12: #define _GNU_SOURCE
13: #endif
14:
15: #include <stdio.h>
16: #include <stdlib.h>
17: #include <fcntl.h>
18: #include <unistd.h>
19: #include <signal.h>
20: #include <pwd.h>
21: #include <grp.h>
22: #include <sys/stat.h>
23: #include <libgen.h>
24:
25: #include "nest/bird.h"
26: #include "lib/lists.h"
27: #include "lib/resource.h"
28: #include "lib/socket.h"
29: #include "lib/event.h"
30: #include "lib/string.h"
31: #include "nest/route.h"
32: #include "nest/protocol.h"
33: #include "nest/iface.h"
34: #include "nest/cli.h"
35: #include "nest/locks.h"
36: #include "conf/conf.h"
37: #include "filter/filter.h"
38:
39: #include "unix.h"
40: #include "krt.h"
41:
42: /*
43: * Debugging
44: */
45:
46: #ifdef DEBUGGING
47: static int debug_flag = 1;
48: #else
49: static int debug_flag = 0;
50: #endif
51:
52: void
53: async_dump(void)
54: {
55: debug("INTERNAL STATE DUMP\n\n");
56:
57: rdump(&root_pool);
58: sk_dump_all();
59: tm_dump_all();
60: if_dump_all();
61: neigh_dump_all();
62: rta_dump_all();
63: rt_dump_all();
64: protos_dump_all();
65:
66: debug("\n");
67: }
68:
69: /*
70: * Dropping privileges
71: */
72:
73: #ifdef CONFIG_RESTRICTED_PRIVILEGES
74: #include "lib/syspriv.h"
75: #else
76:
77: static inline void
78: drop_uid(uid_t uid UNUSED)
79: {
80: die("Cannot change user on this platform");
81: }
82:
83: #endif
84:
85: static inline void
86: drop_gid(gid_t gid)
87: {
88: if (setgid(gid) < 0)
89: die("setgid: %m");
90: }
91:
92: /*
93: * Reading the Configuration
94: */
95:
96: #ifdef PATH_IPROUTE_DIR
97:
98: static inline void
99: add_num_const(char *name, int val)
100: {
101: struct symbol *s = cf_get_symbol(name);
102: s->class = SYM_CONSTANT | T_INT;
103: s->def = cfg_allocz(sizeof(struct f_val));
104: SYM_TYPE(s) = T_INT;
105: SYM_VAL(s).i = val;
106: }
107:
108: /* the code of read_iproute_table() is based on
109: rtnl_tab_initialize() from iproute2 package */
110: static void
111: read_iproute_table(char *file, char *prefix, int max)
112: {
113: char buf[512], namebuf[512];
114: char *name;
115: int val;
116: FILE *fp;
117:
118: strcpy(namebuf, prefix);
119: name = namebuf + strlen(prefix);
120:
121: fp = fopen(file, "r");
122: if (!fp)
123: return;
124:
125: while (fgets(buf, sizeof(buf), fp))
126: {
127: char *p = buf;
128:
129: while (*p == ' ' || *p == '\t')
130: p++;
131:
132: if (*p == '#' || *p == '\n' || *p == 0)
133: continue;
134:
135: if (sscanf(p, "0x%x %s\n", &val, name) != 2 &&
136: sscanf(p, "0x%x %s #", &val, name) != 2 &&
137: sscanf(p, "%d %s\n", &val, name) != 2 &&
138: sscanf(p, "%d %s #", &val, name) != 2)
139: continue;
140:
141: if (val < 0 || val > max)
142: continue;
143:
144: for(p = name; *p; p++)
145: if ((*p < 'a' || *p > 'z') && (*p < '0' || *p > '9') && (*p != '_'))
146: *p = '_';
147:
148: add_num_const(namebuf, val);
149: }
150:
151: fclose(fp);
152: }
153:
154: #endif // PATH_IPROUTE_DIR
155:
156:
157: static char *config_name = PATH_CONFIG_FILE;
158:
159: static int
160: cf_read(byte *dest, uint len, int fd)
161: {
162: int l = read(fd, dest, len);
163: if (l < 0)
164: cf_error("Read error");
165: return l;
166: }
167:
168: void
169: sysdep_preconfig(struct config *c)
170: {
171: init_list(&c->logfiles);
172:
173: c->latency_limit = UNIX_DEFAULT_LATENCY_LIMIT;
174: c->watchdog_warning = UNIX_DEFAULT_WATCHDOG_WARNING;
175:
176: #ifdef PATH_IPROUTE_DIR
177: read_iproute_table(PATH_IPROUTE_DIR "/rt_protos", "ipp_", 256);
178: read_iproute_table(PATH_IPROUTE_DIR "/rt_realms", "ipr_", 256);
179: read_iproute_table(PATH_IPROUTE_DIR "/rt_scopes", "ips_", 256);
180: read_iproute_table(PATH_IPROUTE_DIR "/rt_tables", "ipt_", 256);
181: #endif
182: }
183:
184: int
185: sysdep_commit(struct config *new, struct config *old UNUSED)
186: {
187: log_switch(debug_flag, &new->logfiles, new->syslog_name);
188: return 0;
189: }
190:
191: static int
192: unix_read_config(struct config **cp, char *name)
193: {
194: struct config *conf = config_alloc(name);
195: int ret;
196:
197: *cp = conf;
198: conf->file_fd = open(name, O_RDONLY);
199: if (conf->file_fd < 0)
200: return 0;
201: cf_read_hook = cf_read;
202: ret = config_parse(conf);
203: close(conf->file_fd);
204: return ret;
205: }
206:
207: static struct config *
208: read_config(void)
209: {
210: struct config *conf;
211:
212: if (!unix_read_config(&conf, config_name))
213: {
214: if (conf->err_msg)
215: die("%s, line %d: %s", conf->err_file_name, conf->err_lino, conf->err_msg);
216: else
217: die("Unable to open configuration file %s: %m", config_name);
218: }
219:
220: return conf;
221: }
222:
223: void
224: async_config(void)
225: {
226: struct config *conf;
227:
228: log(L_INFO "Reconfiguration requested by SIGHUP");
229: if (!unix_read_config(&conf, config_name))
230: {
231: if (conf->err_msg)
232: log(L_ERR "%s, line %d: %s", conf->err_file_name, conf->err_lino, conf->err_msg);
233: else
234: log(L_ERR "Unable to open configuration file %s: %m", config_name);
235: config_free(conf);
236: }
237: else
238: config_commit(conf, RECONFIG_HARD, 0);
239: }
240:
241: static struct config *
242: cmd_read_config(char *name)
243: {
244: struct config *conf;
245:
246: if (!name)
247: name = config_name;
248:
249: cli_msg(-2, "Reading configuration from %s", name);
250: if (!unix_read_config(&conf, name))
251: {
252: if (conf->err_msg)
253: cli_msg(8002, "%s, line %d: %s", conf->err_file_name, conf->err_lino, conf->err_msg);
254: else
255: cli_msg(8002, "%s: %m", name);
256: config_free(conf);
257: conf = NULL;
258: }
259:
260: return conf;
261: }
262:
263: void
264: cmd_check_config(char *name)
265: {
266: struct config *conf = cmd_read_config(name);
267: if (!conf)
268: return;
269:
270: cli_msg(20, "Configuration OK");
271: config_free(conf);
272: }
273:
274: static void
275: cmd_reconfig_msg(int r)
276: {
277: switch (r)
278: {
279: case CONF_DONE: cli_msg( 3, "Reconfigured"); break;
280: case CONF_PROGRESS: cli_msg( 4, "Reconfiguration in progress"); break;
281: case CONF_QUEUED: cli_msg( 5, "Reconfiguration already in progress, queueing new config"); break;
282: case CONF_UNQUEUED: cli_msg(17, "Reconfiguration already in progress, removing queued config"); break;
283: case CONF_CONFIRM: cli_msg(18, "Reconfiguration confirmed"); break;
284: case CONF_SHUTDOWN: cli_msg( 6, "Reconfiguration ignored, shutting down"); break;
285: case CONF_NOTHING: cli_msg(19, "Nothing to do"); break;
286: default: break;
287: }
288: }
289:
290: /* Hack for scheduled undo notification */
291: cli *cmd_reconfig_stored_cli;
292:
293: void
294: cmd_reconfig_undo_notify(void)
295: {
296: if (cmd_reconfig_stored_cli)
297: {
298: cli *c = cmd_reconfig_stored_cli;
299: cli_printf(c, CLI_ASYNC_CODE, "Config timeout expired, starting undo");
300: cli_write_trigger(c);
301: }
302: }
303:
304: void
305: cmd_reconfig(char *name, int type, int timeout)
306: {
307: if (cli_access_restricted())
308: return;
309:
310: struct config *conf = cmd_read_config(name);
311: if (!conf)
312: return;
313:
314: int r = config_commit(conf, type, timeout);
315:
316: if ((r >= 0) && (timeout > 0))
317: {
318: cmd_reconfig_stored_cli = this_cli;
319: cli_msg(-22, "Undo scheduled in %d s", timeout);
320: }
321:
322: cmd_reconfig_msg(r);
323: }
324:
325: void
326: cmd_reconfig_confirm(void)
327: {
328: if (cli_access_restricted())
329: return;
330:
331: int r = config_confirm();
332: cmd_reconfig_msg(r);
333: }
334:
335: void
336: cmd_reconfig_undo(void)
337: {
338: if (cli_access_restricted())
339: return;
340:
341: cli_msg(-21, "Undo requested");
342:
343: int r = config_undo();
344: cmd_reconfig_msg(r);
345: }
346:
347: /*
348: * Command-Line Interface
349: */
350:
351: static sock *cli_sk;
352: static char *path_control_socket = PATH_CONTROL_SOCKET;
353:
354:
355: static void
356: cli_write(cli *c)
357: {
358: sock *s = c->priv;
359:
360: while (c->tx_pos)
361: {
362: struct cli_out *o = c->tx_pos;
363:
364: int len = o->wpos - o->outpos;
365: s->tbuf = o->outpos;
366: o->outpos = o->wpos;
367:
368: if (sk_send(s, len) <= 0)
369: return;
370:
371: c->tx_pos = o->next;
372: }
373:
374: /* Everything is written */
375: s->tbuf = NULL;
376: cli_written(c);
377: }
378:
379: void
380: cli_write_trigger(cli *c)
381: {
382: sock *s = c->priv;
383:
384: if (s->tbuf == NULL)
385: cli_write(c);
386: }
387:
388: static void
389: cli_tx(sock *s)
390: {
391: cli_write(s->data);
392: }
393:
394: int
395: cli_get_command(cli *c)
396: {
397: sock *s = c->priv;
398: byte *t = c->rx_aux ? : s->rbuf;
399: byte *tend = s->rpos;
400: byte *d = c->rx_pos;
401: byte *dend = c->rx_buf + CLI_RX_BUF_SIZE - 2;
402:
403: while (t < tend)
404: {
405: if (*t == '\r')
406: t++;
407: else if (*t == '\n')
408: {
409: t++;
410: c->rx_pos = c->rx_buf;
411: c->rx_aux = t;
412: *d = 0;
413: return (d < dend) ? 1 : -1;
414: }
415: else if (d < dend)
416: *d++ = *t++;
417: }
418: c->rx_aux = s->rpos = s->rbuf;
419: c->rx_pos = d;
420: return 0;
421: }
422:
423: static int
424: cli_rx(sock *s, uint size UNUSED)
425: {
426: cli_kick(s->data);
427: return 0;
428: }
429:
430: static void
431: cli_err(sock *s, int err)
432: {
433: if (config->cli_debug)
434: {
435: if (err)
436: log(L_INFO "CLI connection dropped: %s", strerror(err));
437: else
438: log(L_INFO "CLI connection closed");
439: }
440: cli_free(s->data);
441: }
442:
443: static int
444: cli_connect(sock *s, uint size UNUSED)
445: {
446: cli *c;
447:
448: if (config->cli_debug)
449: log(L_INFO "CLI connect");
450: s->rx_hook = cli_rx;
451: s->tx_hook = cli_tx;
452: s->err_hook = cli_err;
453: s->data = c = cli_new(s);
454: s->pool = c->pool; /* We need to have all the socket buffers allocated in the cli pool */
455: s->fast_rx = 1;
456: c->rx_pos = c->rx_buf;
457: c->rx_aux = NULL;
458: rmove(s, c->pool);
459: return 1;
460: }
461:
462: static void
463: cli_init_unix(uid_t use_uid, gid_t use_gid)
464: {
465: sock *s;
466:
467: cli_init();
468: s = cli_sk = sk_new(cli_pool);
469: s->type = SK_UNIX_PASSIVE;
470: s->rx_hook = cli_connect;
471: s->rbsize = 1024;
472: s->fast_rx = 1;
473:
474: /* Return value intentionally ignored */
475: unlink(path_control_socket);
476:
477: if (sk_open_unix(s, path_control_socket) < 0)
478: die("Cannot create control socket %s: %m", path_control_socket);
479:
480: if (use_uid || use_gid)
481: if (chown(path_control_socket, use_uid, use_gid) < 0)
482: die("chown: %m");
483:
484: if (chmod(path_control_socket, 0660) < 0)
485: die("chmod: %m");
486: }
487:
488: /*
489: * PID file
490: */
491:
492: static char *pid_file;
493: static int pid_fd;
494:
495: static inline void
496: open_pid_file(void)
497: {
498: if (!pid_file)
499: return;
500:
501: pid_fd = open(pid_file, O_WRONLY|O_CREAT, 0664);
502: if (pid_fd < 0)
503: die("Cannot create PID file %s: %m", pid_file);
504: }
505:
506: static inline void
507: write_pid_file(void)
508: {
509: int pl, rv;
510: char ps[24];
511:
512: if (!pid_file)
513: return;
514:
515: /* We don't use PID file for uniqueness, so no need for locking */
516:
517: pl = bsnprintf(ps, sizeof(ps), "%ld\n", (long) getpid());
518: if (pl < 0)
519: bug("PID buffer too small");
520:
521: rv = ftruncate(pid_fd, 0);
522: if (rv < 0)
523: die("fruncate: %m");
524:
525: rv = write(pid_fd, ps, pl);
526: if(rv < 0)
527: die("write: %m");
528:
529: close(pid_fd);
530: }
531:
532: static inline void
533: unlink_pid_file(void)
534: {
535: if (pid_file)
536: unlink(pid_file);
537: }
538:
539:
540: /*
541: * Shutdown
542: */
543:
544: void
545: cmd_shutdown(void)
546: {
547: if (cli_access_restricted())
548: return;
549:
550: cli_msg(7, "Shutdown requested");
551: order_shutdown();
552: }
553:
554: void
555: async_shutdown(void)
556: {
557: DBG("Shutting down...\n");
558: order_shutdown();
559: }
560:
561: void
562: sysdep_shutdown_done(void)
563: {
564: unlink_pid_file();
565: unlink(path_control_socket);
566: log_msg(L_FATAL "Shutdown completed");
567: exit(0);
568: }
569:
570: /*
571: * Signals
572: */
573:
574: static void
575: handle_sighup(int sig UNUSED)
576: {
577: DBG("Caught SIGHUP...\n");
578: async_config_flag = 1;
579: }
580:
581: static void
582: handle_sigusr(int sig UNUSED)
583: {
584: DBG("Caught SIGUSR...\n");
585: async_dump_flag = 1;
586: }
587:
588: static void
589: handle_sigterm(int sig UNUSED)
590: {
591: DBG("Caught SIGTERM...\n");
592: async_shutdown_flag = 1;
593: }
594:
595: void watchdog_sigalrm(int sig UNUSED);
596:
597: static void
598: signal_init(void)
599: {
600: struct sigaction sa;
601:
602: bzero(&sa, sizeof(sa));
603: sa.sa_handler = handle_sigusr;
604: sa.sa_flags = SA_RESTART;
605: sigaction(SIGUSR1, &sa, NULL);
606: sa.sa_handler = handle_sighup;
607: sa.sa_flags = SA_RESTART;
608: sigaction(SIGHUP, &sa, NULL);
609: sa.sa_handler = handle_sigterm;
610: sa.sa_flags = SA_RESTART;
611: sigaction(SIGTERM, &sa, NULL);
612: sa.sa_handler = watchdog_sigalrm;
613: sa.sa_flags = 0;
614: sigaction(SIGALRM, &sa, NULL);
615: signal(SIGPIPE, SIG_IGN);
616: }
617:
618: /*
619: * Parsing of command-line arguments
620: */
621:
622: static char *opt_list = "c:dD:ps:P:u:g:flRh";
623: static int parse_and_exit;
624: char *bird_name;
625: static char *use_user;
626: static char *use_group;
627: static int run_in_foreground = 0;
628:
629: static void
630: display_usage(void)
631: {
632: fprintf(stderr, "Usage: %s [--version] [--help] [-c <config-file>] [OPTIONS]\n", bird_name);
633: }
634:
635: static void
636: display_help(void)
637: {
638: display_usage();
639:
640: fprintf(stderr,
641: "\n"
642: "Options: \n"
643: " -c <config-file> Use given configuration file instead\n"
644: " of prefix/etc/bird.conf\n"
645: " -d Enable debug messages and run bird in foreground\n"
646: " -D <debug-file> Log debug messages to given file instead of stderr\n"
647: " -f Run bird in foreground\n"
648: " -g <group> Use given group ID\n"
649: " -h, --help Display this information\n"
650: " -l Look for a configuration file and a communication socket\n"
651: " file in the current working directory\n"
652: " -p Test configuration file and exit without start\n"
653: " -P <pid-file> Create a PID file with given filename\n"
654: " -R Apply graceful restart recovery after start\n"
655: " -s <control-socket> Use given filename for a control socket\n"
656: " -u <user> Drop privileges and use given user ID\n"
657: " --version Display version of BIRD\n");
658:
659: exit(0);
660: }
661:
662: static void
663: display_version(void)
664: {
665: fprintf(stderr, "BIRD version " BIRD_VERSION "\n");
666: exit(0);
667: }
668:
669: static inline char *
670: get_bird_name(char *s, char *def)
671: {
672: char *t;
673: if (!s)
674: return def;
675: t = strrchr(s, '/');
676: if (!t)
677: return s;
678: if (!t[1])
679: return def;
680: return t+1;
681: }
682:
683: static inline uid_t
684: get_uid(const char *s)
685: {
686: struct passwd *pw;
687: char *endptr;
688: long int rv;
689:
690: if (!s)
691: return 0;
692:
693: errno = 0;
694: rv = strtol(s, &endptr, 10);
695:
696: if (!errno && !*endptr)
697: return rv;
698:
699: pw = getpwnam(s);
700: if (!pw)
701: die("Cannot find user '%s'", s);
702:
703: return pw->pw_uid;
704: }
705:
706: static inline gid_t
707: get_gid(const char *s)
708: {
709: struct group *gr;
710: char *endptr;
711: long int rv;
712:
713: if (!s)
714: return 0;
715:
716: errno = 0;
717: rv = strtol(s, &endptr, 10);
718:
719: if (!errno && !*endptr)
720: return rv;
721:
722: gr = getgrnam(s);
723: if (!gr)
724: die("Cannot find group '%s'", s);
725:
726: return gr->gr_gid;
727: }
728:
729: static void
730: parse_args(int argc, char **argv)
731: {
732: int config_changed = 0;
733: int socket_changed = 0;
734: int c;
735:
736: bird_name = get_bird_name(argv[0], "bird");
737: if (argc == 2)
738: {
739: if (!strcmp(argv[1], "--version"))
740: display_version();
741: if (!strcmp(argv[1], "--help"))
742: display_help();
743: }
744: while ((c = getopt(argc, argv, opt_list)) >= 0)
745: switch (c)
746: {
747: case 'c':
748: config_name = optarg;
749: config_changed = 1;
750: break;
751: case 'd':
752: debug_flag |= 1;
753: break;
754: case 'D':
755: log_init_debug(optarg);
756: debug_flag |= 2;
757: break;
758: case 'p':
759: parse_and_exit = 1;
760: break;
761: case 's':
762: path_control_socket = optarg;
763: socket_changed = 1;
764: break;
765: case 'P':
766: pid_file = optarg;
767: break;
768: case 'u':
769: use_user = optarg;
770: break;
771: case 'g':
772: use_group = optarg;
773: break;
774: case 'f':
775: run_in_foreground = 1;
776: break;
777: case 'l':
778: if (!config_changed)
779: config_name = xbasename(config_name);
780: if (!socket_changed)
781: path_control_socket = xbasename(path_control_socket);
782: break;
783: case 'R':
784: graceful_restart_recovery();
785: break;
786: case 'h':
787: display_help();
788: break;
789: default:
790: fputc('\n', stderr);
791: display_usage();
792: exit(1);
793: }
794: if (optind < argc)
795: {
796: display_usage();
797: exit(1);
798: }
799: }
800:
801: /*
802: * Hic Est main()
803: */
804:
805: int
806: main(int argc, char **argv)
807: {
808: #ifdef HAVE_LIBDMALLOC
809: if (!getenv("DMALLOC_OPTIONS"))
810: dmalloc_debug(0x2f03d00);
811: #endif
812:
813: parse_args(argc, argv);
814: if (debug_flag == 1)
815: log_init_debug("");
816: log_switch(debug_flag, NULL, NULL);
817:
818: resource_init();
819: olock_init();
820: io_init();
821: rt_init();
822: if_init();
823: roa_init();
824: config_init();
825:
826: uid_t use_uid = get_uid(use_user);
827: gid_t use_gid = get_gid(use_group);
828:
829: if (!parse_and_exit)
830: {
831: test_old_bird(path_control_socket);
832: cli_init_unix(use_uid, use_gid);
833: }
834:
835: if (use_gid)
836: drop_gid(use_gid);
837:
838: if (use_uid)
839: drop_uid(use_uid);
840:
841: if (!parse_and_exit)
842: open_pid_file();
843:
844: protos_build();
845: proto_build(&proto_unix_kernel);
846: proto_build(&proto_unix_iface);
847:
848: struct config *conf = read_config();
849:
850: if (parse_and_exit)
851: exit(0);
852:
853: if (!(debug_flag||run_in_foreground))
854: {
855: pid_t pid = fork();
856: if (pid < 0)
857: die("fork: %m");
858: if (pid)
859: return 0;
860: setsid();
861: close(0);
862: if (open("/dev/null", O_RDWR) < 0)
863: die("Cannot open /dev/null: %m");
864: dup2(0, 1);
865: dup2(0, 2);
866: }
867:
868: main_thread_init();
869:
870: write_pid_file();
871:
872: signal_init();
873:
874: config_commit(conf, RECONFIG_HARD, 0);
875:
876: graceful_restart_init();
877:
878: #ifdef LOCAL_DEBUG
879: async_dump_flag = 1;
880: #endif
881:
882: log(L_INFO "Started");
883: DBG("Entering I/O loop.\n");
884:
885: io_loop();
886: bug("I/O loop died");
887: }