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