| File: | src/usr.sbin/bgpd/bgpd.c |
| Warning: | line 329, column 26 Dereference of null pointer |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* $OpenBSD: bgpd.c,v 1.262 2024/01/09 13:41:32 claudio Exp $ */ | |||
| 2 | ||||
| 3 | /* | |||
| 4 | * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> | |||
| 5 | * | |||
| 6 | * Permission to use, copy, modify, and distribute this software for any | |||
| 7 | * purpose with or without fee is hereby granted, provided that the above | |||
| 8 | * copyright notice and this permission notice appear in all copies. | |||
| 9 | * | |||
| 10 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |||
| 11 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |||
| 12 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |||
| 13 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |||
| 14 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |||
| 15 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |||
| 16 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |||
| 17 | */ | |||
| 18 | ||||
| 19 | #include <sys/types.h> | |||
| 20 | #include <sys/socket.h> | |||
| 21 | #include <sys/wait.h> | |||
| 22 | #include <netinet/in.h> | |||
| 23 | #include <arpa/inet.h> | |||
| 24 | #include <err.h> | |||
| 25 | #include <errno(*__errno()).h> | |||
| 26 | #include <fcntl.h> | |||
| 27 | #include <poll.h> | |||
| 28 | #include <pwd.h> | |||
| 29 | #include <signal.h> | |||
| 30 | #include <stddef.h> | |||
| 31 | #include <stdio.h> | |||
| 32 | #include <stdlib.h> | |||
| 33 | #include <string.h> | |||
| 34 | #include <syslog.h> | |||
| 35 | #include <unistd.h> | |||
| 36 | ||||
| 37 | #include "bgpd.h" | |||
| 38 | #include "session.h" | |||
| 39 | #include "log.h" | |||
| 40 | #include "version.h" | |||
| 41 | ||||
| 42 | void sighdlr(int); | |||
| 43 | __dead__attribute__((__noreturn__)) void usage(void); | |||
| 44 | int main(int, char *[]); | |||
| 45 | pid_t start_child(enum bgpd_process, char *, int, int, int); | |||
| 46 | int send_filterset(struct imsgbuf *, struct filter_set_head *); | |||
| 47 | int reconfigure(char *, struct bgpd_config *); | |||
| 48 | int send_config(struct bgpd_config *); | |||
| 49 | int dispatch_imsg(struct imsgbuf *, int, struct bgpd_config *); | |||
| 50 | int control_setup(struct bgpd_config *); | |||
| 51 | static void getsockpair(int [2]); | |||
| 52 | int imsg_send_sockets(struct imsgbuf *, struct imsgbuf *, | |||
| 53 | struct imsgbuf *); | |||
| 54 | void bgpd_rtr_connect(struct rtr_config *); | |||
| 55 | void bgpd_rtr_connect_done(int, struct bgpd_config *); | |||
| 56 | ||||
| 57 | int cflags; | |||
| 58 | volatile sig_atomic_t mrtdump; | |||
| 59 | volatile sig_atomic_t quit; | |||
| 60 | volatile sig_atomic_t reconfig; | |||
| 61 | pid_t reconfpid; | |||
| 62 | int reconfpending; | |||
| 63 | struct imsgbuf *ibuf_se; | |||
| 64 | struct imsgbuf *ibuf_rde; | |||
| 65 | struct imsgbuf *ibuf_rtr; | |||
| 66 | struct rib_names ribnames = SIMPLEQ_HEAD_INITIALIZER(ribnames){ ((void *)0), &(ribnames).sqh_first }; | |||
| 67 | char *cname; | |||
| 68 | char *rcname; | |||
| 69 | ||||
| 70 | struct connect_elm { | |||
| 71 | TAILQ_ENTRY(connect_elm)struct { struct connect_elm *tqe_next; struct connect_elm **tqe_prev ; } entry; | |||
| 72 | uint32_t id; | |||
| 73 | int fd; | |||
| 74 | }; | |||
| 75 | ||||
| 76 | TAILQ_HEAD(, connect_elm)struct { struct connect_elm *tqh_first; struct connect_elm ** tqh_last; } connect_queue = \ | |||
| 77 | TAILQ_HEAD_INITIALIZER(connect_queue){ ((void *)0), &(connect_queue).tqh_first }; | |||
| 78 | u_int connect_cnt; | |||
| 79 | #define MAX_CONNECT_CNT32 32 | |||
| 80 | ||||
| 81 | void | |||
| 82 | sighdlr(int sig) | |||
| 83 | { | |||
| 84 | switch (sig) { | |||
| 85 | case SIGTERM15: | |||
| 86 | case SIGINT2: | |||
| 87 | quit = 1; | |||
| 88 | break; | |||
| 89 | case SIGHUP1: | |||
| 90 | reconfig = 1; | |||
| 91 | break; | |||
| 92 | case SIGALRM14: | |||
| 93 | case SIGUSR130: | |||
| 94 | mrtdump = 1; | |||
| 95 | break; | |||
| 96 | } | |||
| 97 | } | |||
| 98 | ||||
| 99 | __dead__attribute__((__noreturn__)) void | |||
| 100 | usage(void) | |||
| 101 | { | |||
| 102 | extern char *__progname; | |||
| 103 | ||||
| 104 | fprintf(stderr(&__sF[2]), "usage: %s [-cdnvV] [-D macro=value] [-f file]\n", | |||
| 105 | __progname); | |||
| 106 | exit(1); | |||
| 107 | } | |||
| 108 | ||||
| 109 | #define PFD_PIPE_SESSION0 0 | |||
| 110 | #define PFD_PIPE_RDE1 1 | |||
| 111 | #define PFD_PIPE_RTR2 2 | |||
| 112 | #define PFD_SOCK_ROUTE3 3 | |||
| 113 | #define PFD_SOCK_PFKEY4 4 | |||
| 114 | #define PFD_CONNECT_START5 5 | |||
| 115 | #define MAX_TIMEOUT3600 3600 | |||
| 116 | ||||
| 117 | int cmd_opts; | |||
| 118 | ||||
| 119 | int | |||
| 120 | main(int argc, char *argv[]) | |||
| 121 | { | |||
| 122 | struct bgpd_config *conf; | |||
| 123 | enum bgpd_process proc = PROC_MAIN; | |||
| 124 | struct rde_rib *rr; | |||
| 125 | struct peer *p; | |||
| 126 | struct pollfd *pfd = NULL((void *)0); | |||
| ||||
| 127 | struct connect_elm *ce; | |||
| 128 | time_t timeout; | |||
| 129 | pid_t se_pid = 0, rde_pid = 0, rtr_pid = 0, pid; | |||
| 130 | char *conffile; | |||
| 131 | char *saved_argv0; | |||
| 132 | u_int pfd_elms = 0, npfd, i; | |||
| 133 | int debug = 0; | |||
| 134 | int rfd, keyfd; | |||
| 135 | int ch, status; | |||
| 136 | int pipe_m2s[2]; | |||
| 137 | int pipe_m2r[2]; | |||
| 138 | int pipe_m2roa[2]; | |||
| 139 | ||||
| 140 | conffile = CONFFILE"/etc/bgpd.conf"; | |||
| 141 | ||||
| 142 | log_init(1, LOG_DAEMON(3<<3)); /* log to stderr until daemonized */ | |||
| 143 | log_procinit(log_procnames[PROC_MAIN]); | |||
| 144 | log_setverbose(1); | |||
| 145 | ||||
| 146 | saved_argv0 = argv[0]; | |||
| 147 | if (saved_argv0 == NULL((void *)0)) | |||
| 148 | saved_argv0 = "bgpd"; | |||
| 149 | ||||
| 150 | while ((ch = getopt(argc, argv, "cdD:f:nRSTvV")) != -1) { | |||
| 151 | switch (ch) { | |||
| 152 | case 'c': | |||
| 153 | cmd_opts |= BGPD_OPT_FORCE_DEMOTE0x0008; | |||
| 154 | break; | |||
| 155 | case 'd': | |||
| 156 | debug = 1; | |||
| 157 | break; | |||
| 158 | case 'D': | |||
| 159 | if (cmdline_symset(optarg) < 0) | |||
| 160 | log_warnx("could not parse macro definition %s", | |||
| 161 | optarg); | |||
| 162 | break; | |||
| 163 | case 'f': | |||
| 164 | conffile = optarg; | |||
| 165 | break; | |||
| 166 | case 'n': | |||
| 167 | cmd_opts |= BGPD_OPT_NOACTION0x0004; | |||
| 168 | break; | |||
| 169 | case 'v': | |||
| 170 | if (cmd_opts & BGPD_OPT_VERBOSE0x0001) | |||
| 171 | cmd_opts |= BGPD_OPT_VERBOSE20x0002; | |||
| 172 | cmd_opts |= BGPD_OPT_VERBOSE0x0001; | |||
| 173 | break; | |||
| 174 | case 'R': | |||
| 175 | proc = PROC_RDE; | |||
| 176 | break; | |||
| 177 | case 'S': | |||
| 178 | proc = PROC_SE; | |||
| 179 | break; | |||
| 180 | case 'T': | |||
| 181 | proc = PROC_RTR; | |||
| 182 | break; | |||
| 183 | case 'V': | |||
| 184 | fprintf(stderr(&__sF[2]), "OpenBGPD %s\n", BGPD_VERSION"8.3"); | |||
| 185 | return 0; | |||
| 186 | default: | |||
| 187 | usage(); | |||
| 188 | /* NOTREACHED */ | |||
| 189 | } | |||
| 190 | } | |||
| 191 | ||||
| 192 | argc -= optind; | |||
| 193 | argv += optind; | |||
| 194 | if (argc > 0) | |||
| 195 | usage(); | |||
| 196 | ||||
| 197 | if (cmd_opts & BGPD_OPT_NOACTION0x0004) { | |||
| 198 | if ((conf = parse_config(conffile, NULL((void *)0), NULL((void *)0))) == NULL((void *)0)) | |||
| 199 | exit(1); | |||
| 200 | ||||
| 201 | if (cmd_opts & BGPD_OPT_VERBOSE0x0001) | |||
| 202 | print_config(conf, &ribnames); | |||
| 203 | else | |||
| 204 | fprintf(stderr(&__sF[2]), "configuration OK\n"); | |||
| 205 | ||||
| 206 | while ((rr = SIMPLEQ_FIRST(&ribnames)((&ribnames)->sqh_first)) != NULL((void *)0)) { | |||
| 207 | SIMPLEQ_REMOVE_HEAD(&ribnames, entry)do { if (((&ribnames)->sqh_first = (&ribnames)-> sqh_first->entry.sqe_next) == ((void *)0)) (&ribnames) ->sqh_last = &(&ribnames)->sqh_first; } while ( 0); | |||
| 208 | free(rr); | |||
| 209 | } | |||
| 210 | free_config(conf); | |||
| 211 | exit(0); | |||
| 212 | } | |||
| 213 | ||||
| 214 | switch (proc) { | |||
| 215 | case PROC_MAIN: | |||
| 216 | break; | |||
| 217 | case PROC_RDE: | |||
| 218 | rde_main(debug, cmd_opts & BGPD_OPT_VERBOSE0x0001); | |||
| 219 | /* NOTREACHED */ | |||
| 220 | case PROC_SE: | |||
| 221 | session_main(debug, cmd_opts & BGPD_OPT_VERBOSE0x0001); | |||
| 222 | /* NOTREACHED */ | |||
| 223 | case PROC_RTR: | |||
| 224 | rtr_main(debug, cmd_opts & BGPD_OPT_VERBOSE0x0001); | |||
| 225 | /* NOTREACHED */ | |||
| 226 | } | |||
| 227 | ||||
| 228 | if (geteuid()) | |||
| 229 | errx(1, "need root privileges"); | |||
| 230 | ||||
| 231 | if (getpwnam(BGPD_USER"_bgpd") == NULL((void *)0)) | |||
| 232 | errx(1, "unknown user %s", BGPD_USER"_bgpd"); | |||
| 233 | ||||
| 234 | if ((conf = parse_config(conffile, NULL((void *)0), NULL((void *)0))) == NULL((void *)0)) { | |||
| 235 | log_warnx("config file %s has errors", conffile); | |||
| 236 | exit(1); | |||
| 237 | } | |||
| 238 | ||||
| 239 | if (prepare_listeners(conf) == -1) | |||
| 240 | exit(1); | |||
| 241 | ||||
| 242 | log_init(debug, LOG_DAEMON(3<<3)); | |||
| 243 | log_setverbose(cmd_opts & BGPD_OPT_VERBOSE0x0001); | |||
| 244 | ||||
| 245 | if (!debug
| |||
| 246 | daemon(1, 0); | |||
| 247 | ||||
| 248 | log_info("startup"); | |||
| 249 | ||||
| 250 | getsockpair(pipe_m2s); | |||
| 251 | getsockpair(pipe_m2r); | |||
| 252 | getsockpair(pipe_m2roa); | |||
| 253 | ||||
| 254 | /* fork children */ | |||
| 255 | rde_pid = start_child(PROC_RDE, saved_argv0, pipe_m2r[1], debug, | |||
| 256 | cmd_opts & BGPD_OPT_VERBOSE0x0001); | |||
| 257 | se_pid = start_child(PROC_SE, saved_argv0, pipe_m2s[1], debug, | |||
| 258 | cmd_opts & BGPD_OPT_VERBOSE0x0001); | |||
| 259 | rtr_pid = start_child(PROC_RTR, saved_argv0, pipe_m2roa[1], debug, | |||
| 260 | cmd_opts & BGPD_OPT_VERBOSE0x0001); | |||
| 261 | ||||
| 262 | signal(SIGTERM15, sighdlr); | |||
| 263 | signal(SIGINT2, sighdlr); | |||
| 264 | signal(SIGHUP1, sighdlr); | |||
| 265 | signal(SIGALRM14, sighdlr); | |||
| 266 | signal(SIGUSR130, sighdlr); | |||
| 267 | signal(SIGPIPE13, SIG_IGN(void (*)(int))1); | |||
| 268 | ||||
| 269 | if ((ibuf_se = malloc(sizeof(struct imsgbuf))) == NULL((void *)0) || | |||
| 270 | (ibuf_rde = malloc(sizeof(struct imsgbuf))) == NULL((void *)0) || | |||
| 271 | (ibuf_rtr = malloc(sizeof(struct imsgbuf))) == NULL((void *)0)) | |||
| 272 | fatal(NULL((void *)0)); | |||
| 273 | imsg_init(ibuf_se, pipe_m2s[0]); | |||
| 274 | imsg_init(ibuf_rde, pipe_m2r[0]); | |||
| 275 | imsg_init(ibuf_rtr, pipe_m2roa[0]); | |||
| 276 | mrt_init(ibuf_rde, ibuf_se); | |||
| 277 | if (kr_init(&rfd, conf->fib_priority) == -1) | |||
| 278 | quit = 1; | |||
| 279 | keyfd = pfkey_init(); | |||
| 280 | ||||
| 281 | /* | |||
| 282 | * rpath, read config file | |||
| 283 | * cpath, unlink control socket | |||
| 284 | * fattr, chmod on control socket | |||
| 285 | * wpath, needed if we are doing mrt dumps | |||
| 286 | * | |||
| 287 | * pledge placed here because kr_init() does a setsockopt on the | |||
| 288 | * routing socket thats not allowed at all. | |||
| 289 | */ | |||
| 290 | #if 0 | |||
| 291 | /* | |||
| 292 | * disabled because we do ioctls on /dev/pf and SIOCSIFGATTR | |||
| 293 | * this needs some redesign of bgpd to be fixed. | |||
| 294 | */ | |||
| 295 | BROKEN if (pledge("stdio rpath wpath cpath fattr unix route recvfd sendfd", | |||
| 296 | NULL((void *)0)) == -1) | |||
| 297 | fatal("pledge"); | |||
| 298 | #endif | |||
| 299 | ||||
| 300 | if (imsg_send_sockets(ibuf_se, ibuf_rde, ibuf_rtr)) | |||
| 301 | fatal("could not establish imsg links"); | |||
| 302 | /* control setup needs to happen late since it sends imsgs */ | |||
| 303 | if (control_setup(conf) == -1) | |||
| 304 | quit = 1; | |||
| 305 | if (send_config(conf) != 0) | |||
| 306 | quit = 1; | |||
| 307 | if (pftable_clear_all() != 0) | |||
| 308 | quit = 1; | |||
| 309 | ||||
| 310 | while (quit == 0) { | |||
| 311 | if (pfd_elms < PFD_CONNECT_START5 + connect_cnt) { | |||
| 312 | struct pollfd *newp; | |||
| 313 | ||||
| 314 | if ((newp = reallocarray(pfd, | |||
| 315 | PFD_CONNECT_START5 + connect_cnt, | |||
| 316 | sizeof(struct pollfd))) == NULL((void *)0)) { | |||
| 317 | log_warn("could not resize pfd from %u -> %u" | |||
| 318 | " entries", pfd_elms, PFD_CONNECT_START5 + | |||
| 319 | connect_cnt); | |||
| 320 | fatalx("exiting"); | |||
| 321 | } | |||
| 322 | pfd = newp; | |||
| 323 | pfd_elms = PFD_CONNECT_START5 + connect_cnt; | |||
| 324 | } | |||
| 325 | memset(pfd, 0, sizeof(struct pollfd) * pfd_elms); | |||
| 326 | ||||
| 327 | timeout = mrt_timeout(conf->mrt); | |||
| 328 | ||||
| 329 | pfd[PFD_SOCK_ROUTE3].fd = rfd; | |||
| ||||
| 330 | pfd[PFD_SOCK_ROUTE3].events = POLLIN0x0001; | |||
| 331 | ||||
| 332 | pfd[PFD_SOCK_PFKEY4].fd = keyfd; | |||
| 333 | pfd[PFD_SOCK_PFKEY4].events = POLLIN0x0001; | |||
| 334 | ||||
| 335 | set_pollfd(&pfd[PFD_PIPE_SESSION0], ibuf_se); | |||
| 336 | set_pollfd(&pfd[PFD_PIPE_RDE1], ibuf_rde); | |||
| 337 | set_pollfd(&pfd[PFD_PIPE_RTR2], ibuf_rtr); | |||
| 338 | ||||
| 339 | npfd = PFD_CONNECT_START5; | |||
| 340 | TAILQ_FOREACH(ce, &connect_queue, entry)for((ce) = ((&connect_queue)->tqh_first); (ce) != ((void *)0); (ce) = ((ce)->entry.tqe_next)) { | |||
| 341 | pfd[npfd].fd = ce->fd; | |||
| 342 | pfd[npfd++].events = POLLOUT0x0004; | |||
| 343 | if (npfd > pfd_elms) | |||
| 344 | fatalx("polli pfd overflow"); | |||
| 345 | } | |||
| 346 | ||||
| 347 | if (timeout < 0 || timeout > MAX_TIMEOUT3600) | |||
| 348 | timeout = MAX_TIMEOUT3600; | |||
| 349 | if (poll(pfd, npfd, timeout * 1000) == -1) { | |||
| 350 | if (errno(*__errno()) != EINTR4) { | |||
| 351 | log_warn("poll error"); | |||
| 352 | quit = 1; | |||
| 353 | } | |||
| 354 | goto next_loop; | |||
| 355 | } | |||
| 356 | ||||
| 357 | if (handle_pollfd(&pfd[PFD_PIPE_SESSION0], ibuf_se) == -1) { | |||
| 358 | log_warnx("main: Lost connection to SE"); | |||
| 359 | msgbuf_clear(&ibuf_se->w); | |||
| 360 | free(ibuf_se); | |||
| 361 | ibuf_se = NULL((void *)0); | |||
| 362 | quit = 1; | |||
| 363 | } else { | |||
| 364 | if (dispatch_imsg(ibuf_se, PFD_PIPE_SESSION0, conf) == | |||
| 365 | -1) | |||
| 366 | quit = 1; | |||
| 367 | } | |||
| 368 | ||||
| 369 | if (handle_pollfd(&pfd[PFD_PIPE_RDE1], ibuf_rde) == -1) { | |||
| 370 | log_warnx("main: Lost connection to RDE"); | |||
| 371 | msgbuf_clear(&ibuf_rde->w); | |||
| 372 | free(ibuf_rde); | |||
| 373 | ibuf_rde = NULL((void *)0); | |||
| 374 | quit = 1; | |||
| 375 | } else { | |||
| 376 | if (dispatch_imsg(ibuf_rde, PFD_PIPE_RDE1, conf) == -1) | |||
| 377 | quit = 1; | |||
| 378 | } | |||
| 379 | ||||
| 380 | if (handle_pollfd(&pfd[PFD_PIPE_RTR2], ibuf_rtr) == -1) { | |||
| 381 | log_warnx("main: Lost connection to RTR"); | |||
| 382 | msgbuf_clear(&ibuf_rtr->w); | |||
| 383 | free(ibuf_rtr); | |||
| 384 | ibuf_rtr = NULL((void *)0); | |||
| 385 | quit = 1; | |||
| 386 | } else { | |||
| 387 | if (dispatch_imsg(ibuf_rtr, PFD_PIPE_RTR2, conf) == -1) | |||
| 388 | quit = 1; | |||
| 389 | } | |||
| 390 | ||||
| 391 | if (pfd[PFD_SOCK_ROUTE3].revents & POLLIN0x0001) { | |||
| 392 | if (kr_dispatch_msg() == -1) | |||
| 393 | quit = 1; | |||
| 394 | } | |||
| 395 | ||||
| 396 | if (pfd[PFD_SOCK_PFKEY4].revents & POLLIN0x0001) { | |||
| 397 | if (pfkey_read(keyfd, NULL((void *)0)) == -1) { | |||
| 398 | log_warnx("pfkey_read failed, exiting..."); | |||
| 399 | quit = 1; | |||
| 400 | } | |||
| 401 | } | |||
| 402 | ||||
| 403 | for (i = PFD_CONNECT_START5; i < npfd; i++) | |||
| 404 | if (pfd[i].revents != 0) | |||
| 405 | bgpd_rtr_connect_done(pfd[i].fd, conf); | |||
| 406 | ||||
| 407 | next_loop: | |||
| 408 | if (reconfig) { | |||
| 409 | u_int error; | |||
| 410 | ||||
| 411 | reconfig = 0; | |||
| 412 | switch (reconfigure(conffile, conf)) { | |||
| 413 | case -1: /* fatal error */ | |||
| 414 | quit = 1; | |||
| 415 | break; | |||
| 416 | case 0: /* all OK */ | |||
| 417 | error = 0; | |||
| 418 | break; | |||
| 419 | case 2: | |||
| 420 | log_info("previous reload still running"); | |||
| 421 | error = CTL_RES_PENDING; | |||
| 422 | break; | |||
| 423 | default: /* parse error */ | |||
| 424 | log_warnx("config file %s has errors, " | |||
| 425 | "not reloading", conffile); | |||
| 426 | error = CTL_RES_PARSE_ERROR; | |||
| 427 | break; | |||
| 428 | } | |||
| 429 | if (reconfpid != 0) { | |||
| 430 | send_imsg_session(IMSG_CTL_RESULT, reconfpid, | |||
| 431 | &error, sizeof(error)); | |||
| 432 | reconfpid = 0; | |||
| 433 | } | |||
| 434 | } | |||
| 435 | ||||
| 436 | if (mrtdump) { | |||
| 437 | mrtdump = 0; | |||
| 438 | mrt_handler(conf->mrt); | |||
| 439 | } | |||
| 440 | } | |||
| 441 | ||||
| 442 | /* close pipes */ | |||
| 443 | if (ibuf_se) { | |||
| 444 | msgbuf_clear(&ibuf_se->w); | |||
| 445 | close(ibuf_se->fd); | |||
| 446 | free(ibuf_se); | |||
| 447 | ibuf_se = NULL((void *)0); | |||
| 448 | } | |||
| 449 | if (ibuf_rde) { | |||
| 450 | msgbuf_clear(&ibuf_rde->w); | |||
| 451 | close(ibuf_rde->fd); | |||
| 452 | free(ibuf_rde); | |||
| 453 | ibuf_rde = NULL((void *)0); | |||
| 454 | } | |||
| 455 | if (ibuf_rtr) { | |||
| 456 | msgbuf_clear(&ibuf_rtr->w); | |||
| 457 | close(ibuf_rtr->fd); | |||
| 458 | free(ibuf_rtr); | |||
| 459 | ibuf_rtr = NULL((void *)0); | |||
| 460 | } | |||
| 461 | ||||
| 462 | /* cleanup kernel data structures */ | |||
| 463 | carp_demote_shutdown(); | |||
| 464 | kr_shutdown(); | |||
| 465 | pftable_clear_all(); | |||
| 466 | ||||
| 467 | RB_FOREACH(p, peer_head, &conf->peers)for ((p) = peer_head_RB_MINMAX(&conf->peers, -1); (p) != ((void *)0); (p) = peer_head_RB_NEXT(p)) | |||
| 468 | pfkey_remove(p); | |||
| 469 | ||||
| 470 | while ((rr = SIMPLEQ_FIRST(&ribnames)((&ribnames)->sqh_first)) != NULL((void *)0)) { | |||
| 471 | SIMPLEQ_REMOVE_HEAD(&ribnames, entry)do { if (((&ribnames)->sqh_first = (&ribnames)-> sqh_first->entry.sqe_next) == ((void *)0)) (&ribnames) ->sqh_last = &(&ribnames)->sqh_first; } while ( 0); | |||
| 472 | free(rr); | |||
| 473 | } | |||
| 474 | free_config(conf); | |||
| 475 | ||||
| 476 | log_debug("waiting for children to terminate"); | |||
| 477 | do { | |||
| 478 | pid = wait(&status); | |||
| 479 | if (pid == -1) { | |||
| 480 | if (errno(*__errno()) != EINTR4 && errno(*__errno()) != ECHILD10) | |||
| 481 | fatal("wait"); | |||
| 482 | } else if (WIFSIGNALED(status)(((status) & 0177) != 0177 && ((status) & 0177 ) != 0)) { | |||
| 483 | char *name = "unknown process"; | |||
| 484 | if (pid == rde_pid) | |||
| 485 | name = "route decision engine"; | |||
| 486 | else if (pid == se_pid) | |||
| 487 | name = "session engine"; | |||
| 488 | else if (pid == rtr_pid) | |||
| 489 | name = "rtr engine"; | |||
| 490 | log_warnx("%s terminated; signal %d", name, | |||
| 491 | WTERMSIG(status)(((status) & 0177))); | |||
| 492 | } | |||
| 493 | } while (pid != -1 || (pid == -1 && errno(*__errno()) == EINTR4)); | |||
| 494 | ||||
| 495 | free(rcname); | |||
| 496 | free(cname); | |||
| 497 | ||||
| 498 | log_info("terminating"); | |||
| 499 | return (0); | |||
| 500 | } | |||
| 501 | ||||
| 502 | pid_t | |||
| 503 | start_child(enum bgpd_process p, char *argv0, int fd, int debug, int verbose) | |||
| 504 | { | |||
| 505 | char *argv[5]; | |||
| 506 | int argc = 0; | |||
| 507 | pid_t pid; | |||
| 508 | ||||
| 509 | switch (pid = fork()) { | |||
| 510 | case -1: | |||
| 511 | fatal("cannot fork"); | |||
| 512 | case 0: | |||
| 513 | break; | |||
| 514 | default: | |||
| 515 | close(fd); | |||
| 516 | return (pid); | |||
| 517 | } | |||
| 518 | ||||
| 519 | if (fd != 3) { | |||
| 520 | if (dup2(fd, 3) == -1) | |||
| 521 | fatal("cannot setup imsg fd"); | |||
| 522 | } else if (fcntl(fd, F_SETFD2, 0) == -1) | |||
| 523 | fatal("cannot setup imsg fd"); | |||
| 524 | ||||
| 525 | argv[argc++] = argv0; | |||
| 526 | switch (p) { | |||
| 527 | case PROC_MAIN: | |||
| 528 | fatalx("Can not start main process"); | |||
| 529 | case PROC_RDE: | |||
| 530 | argv[argc++] = "-R"; | |||
| 531 | break; | |||
| 532 | case PROC_SE: | |||
| 533 | argv[argc++] = "-S"; | |||
| 534 | break; | |||
| 535 | case PROC_RTR: | |||
| 536 | argv[argc++] = "-T"; | |||
| 537 | break; | |||
| 538 | } | |||
| 539 | if (debug) | |||
| 540 | argv[argc++] = "-d"; | |||
| 541 | if (verbose) | |||
| 542 | argv[argc++] = "-v"; | |||
| 543 | argv[argc++] = NULL((void *)0); | |||
| 544 | ||||
| 545 | execvp(argv0, argv); | |||
| 546 | fatal("execvp"); | |||
| 547 | } | |||
| 548 | ||||
| 549 | int | |||
| 550 | send_filterset(struct imsgbuf *i, struct filter_set_head *set) | |||
| 551 | { | |||
| 552 | struct filter_set *s; | |||
| 553 | ||||
| 554 | TAILQ_FOREACH(s, set, entry)for((s) = ((set)->tqh_first); (s) != ((void *)0); (s) = (( s)->entry.tqe_next)) | |||
| 555 | if (imsg_compose(i, IMSG_FILTER_SET, 0, 0, -1, s, | |||
| 556 | sizeof(struct filter_set)) == -1) | |||
| 557 | return (-1); | |||
| 558 | return (0); | |||
| 559 | } | |||
| 560 | ||||
| 561 | int | |||
| 562 | reconfigure(char *conffile, struct bgpd_config *conf) | |||
| 563 | { | |||
| 564 | struct bgpd_config *new_conf; | |||
| 565 | ||||
| 566 | if (reconfpending) | |||
| 567 | return (2); | |||
| 568 | ||||
| 569 | log_info("rereading config"); | |||
| 570 | if ((new_conf = parse_config(conffile, &conf->peers, | |||
| 571 | &conf->rtrs)) == NULL((void *)0)) | |||
| 572 | return (1); | |||
| 573 | ||||
| 574 | merge_config(conf, new_conf); | |||
| 575 | ||||
| 576 | if (prepare_listeners(conf) == -1) { | |||
| 577 | return (1); | |||
| 578 | } | |||
| 579 | ||||
| 580 | if (control_setup(conf) == -1) { | |||
| 581 | return (1); | |||
| 582 | } | |||
| 583 | ||||
| 584 | return send_config(conf); | |||
| 585 | } | |||
| 586 | ||||
| 587 | int | |||
| 588 | send_config(struct bgpd_config *conf) | |||
| 589 | { | |||
| 590 | struct peer *p; | |||
| 591 | struct filter_rule *r; | |||
| 592 | struct listen_addr *la; | |||
| 593 | struct rde_rib *rr; | |||
| 594 | struct l3vpn *vpn; | |||
| 595 | struct as_set *aset; | |||
| 596 | struct prefixset *ps; | |||
| 597 | struct prefixset_item *psi, *npsi; | |||
| 598 | struct roa *roa; | |||
| 599 | struct aspa_set *aspa; | |||
| 600 | struct rtr_config *rtr; | |||
| 601 | struct flowspec_config *f, *nf; | |||
| 602 | ||||
| 603 | reconfpending = 3; /* one per child */ | |||
| 604 | ||||
| 605 | expand_networks(conf, &conf->networks); | |||
| 606 | SIMPLEQ_FOREACH(vpn, &conf->l3vpns, entry)for((vpn) = ((&conf->l3vpns)->sqh_first); (vpn) != ( (void *)0); (vpn) = ((vpn)->entry.sqe_next)) | |||
| 607 | expand_networks(conf, &vpn->net_l); | |||
| 608 | ||||
| 609 | cflags = conf->flags; | |||
| 610 | ||||
| 611 | /* start reconfiguration */ | |||
| 612 | if (imsg_compose(ibuf_se, IMSG_RECONF_CONF, 0, 0, -1, | |||
| 613 | conf, sizeof(*conf)) == -1) | |||
| 614 | return (-1); | |||
| 615 | if (imsg_compose(ibuf_rde, IMSG_RECONF_CONF, 0, 0, -1, | |||
| 616 | conf, sizeof(*conf)) == -1) | |||
| 617 | return (-1); | |||
| 618 | if (imsg_compose(ibuf_rtr, IMSG_RECONF_CONF, 0, 0, -1, | |||
| 619 | conf, sizeof(*conf)) == -1) | |||
| 620 | return (-1); | |||
| 621 | ||||
| 622 | TAILQ_FOREACH(la, conf->listen_addrs, entry)for((la) = ((conf->listen_addrs)->tqh_first); (la) != ( (void *)0); (la) = ((la)->entry.tqe_next)) { | |||
| 623 | if (imsg_compose(ibuf_se, IMSG_RECONF_LISTENER, 0, 0, la->fd, | |||
| 624 | la, sizeof(*la)) == -1) | |||
| 625 | return (-1); | |||
| 626 | la->fd = -1; | |||
| 627 | } | |||
| 628 | ||||
| 629 | /* adjust fib syncing on reload */ | |||
| 630 | ktable_preload(); | |||
| 631 | ||||
| 632 | /* RIBs for the RDE */ | |||
| 633 | while ((rr = SIMPLEQ_FIRST(&ribnames)((&ribnames)->sqh_first))) { | |||
| 634 | SIMPLEQ_REMOVE_HEAD(&ribnames, entry)do { if (((&ribnames)->sqh_first = (&ribnames)-> sqh_first->entry.sqe_next) == ((void *)0)) (&ribnames) ->sqh_last = &(&ribnames)->sqh_first; } while ( 0); | |||
| 635 | if (ktable_update(rr->rtableid, rr->name, rr->flags) == -1) { | |||
| 636 | log_warnx("failed to load routing table %d", | |||
| 637 | rr->rtableid); | |||
| 638 | return (-1); | |||
| 639 | } | |||
| 640 | if (imsg_compose(ibuf_rde, IMSG_RECONF_RIB, 0, 0, -1, | |||
| 641 | rr, sizeof(*rr)) == -1) | |||
| 642 | return (-1); | |||
| 643 | free(rr); | |||
| 644 | } | |||
| 645 | ||||
| 646 | /* send peer list to the SE */ | |||
| 647 | RB_FOREACH(p, peer_head, &conf->peers)for ((p) = peer_head_RB_MINMAX(&conf->peers, -1); (p) != ((void *)0); (p) = peer_head_RB_NEXT(p)) { | |||
| 648 | if (imsg_compose(ibuf_se, IMSG_RECONF_PEER, p->conf.id, 0, -1, | |||
| 649 | &p->conf, sizeof(p->conf)) == -1) | |||
| 650 | return (-1); | |||
| 651 | ||||
| 652 | if (p->reconf_action == RECONF_REINIT) | |||
| 653 | if (pfkey_establish(p) == -1) | |||
| 654 | log_peer_warnx(&p->conf, "pfkey setup failed"); | |||
| 655 | } | |||
| 656 | ||||
| 657 | /* networks go via kroute to the RDE */ | |||
| 658 | kr_net_reload(conf->default_tableid, 0, &conf->networks); | |||
| 659 | ||||
| 660 | /* flowspec goes directly to the RDE, also remove old objects */ | |||
| 661 | RB_FOREACH_SAFE(f, flowspec_tree, &conf->flowspecs, nf)for ((f) = flowspec_tree_RB_MINMAX(&conf->flowspecs, - 1); ((f) != ((void *)0)) && ((nf) = flowspec_tree_RB_NEXT (f), 1); (f) = (nf)) { | |||
| 662 | if (f->reconf_action != RECONF_DELETE) { | |||
| 663 | if (imsg_compose(ibuf_rde, IMSG_FLOWSPEC_ADD, 0, 0, -1, | |||
| 664 | f->flow, FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data)) + f->flow->len) == -1) | |||
| 665 | return (-1); | |||
| 666 | if (send_filterset(ibuf_rde, &f->attrset) == -1) | |||
| 667 | return (-1); | |||
| 668 | if (imsg_compose(ibuf_rde, IMSG_FLOWSPEC_DONE, 0, 0, -1, | |||
| 669 | NULL((void *)0), 0) == -1) | |||
| 670 | return (-1); | |||
| 671 | } else { | |||
| 672 | if (imsg_compose(ibuf_rde, IMSG_FLOWSPEC_REMOVE, 0, 0, | |||
| 673 | -1, f->flow, FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data)) + f->flow->len) == -1) | |||
| 674 | return (-1); | |||
| 675 | RB_REMOVE(flowspec_tree, &conf->flowspecs, f)flowspec_tree_RB_REMOVE(&conf->flowspecs, f); | |||
| 676 | flowspec_free(f); | |||
| 677 | } | |||
| 678 | } | |||
| 679 | ||||
| 680 | /* prefixsets for filters in the RDE */ | |||
| 681 | while ((ps = SIMPLEQ_FIRST(&conf->prefixsets)((&conf->prefixsets)->sqh_first)) != NULL((void *)0)) { | |||
| 682 | SIMPLEQ_REMOVE_HEAD(&conf->prefixsets, entry)do { if (((&conf->prefixsets)->sqh_first = (&conf ->prefixsets)->sqh_first->entry.sqe_next) == ((void * )0)) (&conf->prefixsets)->sqh_last = &(&conf ->prefixsets)->sqh_first; } while (0); | |||
| 683 | if (imsg_compose(ibuf_rde, IMSG_RECONF_PREFIX_SET, 0, 0, -1, | |||
| 684 | ps->name, sizeof(ps->name)) == -1) | |||
| 685 | return (-1); | |||
| 686 | RB_FOREACH_SAFE(psi, prefixset_tree, &ps->psitems, npsi)for ((psi) = prefixset_tree_RB_MINMAX(&ps->psitems, -1 ); ((psi) != ((void *)0)) && ((npsi) = prefixset_tree_RB_NEXT (psi), 1); (psi) = (npsi)) { | |||
| 687 | RB_REMOVE(prefixset_tree, &ps->psitems, psi)prefixset_tree_RB_REMOVE(&ps->psitems, psi); | |||
| 688 | if (imsg_compose(ibuf_rde, IMSG_RECONF_PREFIX_SET_ITEM, | |||
| 689 | 0, 0, -1, psi, sizeof(*psi)) == -1) | |||
| 690 | return (-1); | |||
| 691 | free(psi); | |||
| 692 | } | |||
| 693 | free(ps); | |||
| 694 | } | |||
| 695 | ||||
| 696 | /* originsets for filters in the RDE */ | |||
| 697 | while ((ps = SIMPLEQ_FIRST(&conf->originsets)((&conf->originsets)->sqh_first)) != NULL((void *)0)) { | |||
| 698 | SIMPLEQ_REMOVE_HEAD(&conf->originsets, entry)do { if (((&conf->originsets)->sqh_first = (&conf ->originsets)->sqh_first->entry.sqe_next) == ((void * )0)) (&conf->originsets)->sqh_last = &(&conf ->originsets)->sqh_first; } while (0); | |||
| 699 | if (imsg_compose(ibuf_rde, IMSG_RECONF_ORIGIN_SET, 0, 0, -1, | |||
| 700 | ps->name, sizeof(ps->name)) == -1) | |||
| 701 | return (-1); | |||
| 702 | RB_FOREACH(roa, roa_tree, &ps->roaitems)for ((roa) = roa_tree_RB_MINMAX(&ps->roaitems, -1); (roa ) != ((void *)0); (roa) = roa_tree_RB_NEXT(roa)) { | |||
| 703 | if (imsg_compose(ibuf_rde, IMSG_RECONF_ROA_ITEM, 0, 0, | |||
| 704 | -1, roa, sizeof(*roa)) == -1) | |||
| 705 | return (-1); | |||
| 706 | } | |||
| 707 | free_roatree(&ps->roaitems); | |||
| 708 | free(ps); | |||
| 709 | } | |||
| 710 | ||||
| 711 | /* roa table, aspa table and rtr config are sent to the RTR engine */ | |||
| 712 | RB_FOREACH(roa, roa_tree, &conf->roa)for ((roa) = roa_tree_RB_MINMAX(&conf->roa, -1); (roa) != ((void *)0); (roa) = roa_tree_RB_NEXT(roa)) { | |||
| 713 | if (imsg_compose(ibuf_rtr, IMSG_RECONF_ROA_ITEM, 0, 0, | |||
| 714 | -1, roa, sizeof(*roa)) == -1) | |||
| 715 | return (-1); | |||
| 716 | } | |||
| 717 | free_roatree(&conf->roa); | |||
| 718 | RB_FOREACH(aspa, aspa_tree, &conf->aspa)for ((aspa) = aspa_tree_RB_MINMAX(&conf->aspa, -1); (aspa ) != ((void *)0); (aspa) = aspa_tree_RB_NEXT(aspa)) { | |||
| 719 | if (imsg_compose(ibuf_rtr, IMSG_RECONF_ASPA, 0, 0, | |||
| 720 | -1, aspa, offsetof(struct aspa_set, tas)__builtin_offsetof(struct aspa_set, tas)) == -1) | |||
| 721 | return (-1); | |||
| 722 | if (imsg_compose(ibuf_rtr, IMSG_RECONF_ASPA_TAS, 0, 0, | |||
| 723 | -1, aspa->tas, sizeof(*aspa->tas) * aspa->num) == -1) | |||
| 724 | return (-1); | |||
| 725 | if (imsg_compose(ibuf_rtr, IMSG_RECONF_ASPA_DONE, 0, 0, -1, | |||
| 726 | NULL((void *)0), 0) == -1) | |||
| 727 | return -1; | |||
| 728 | } | |||
| 729 | free_aspatree(&conf->aspa); | |||
| 730 | SIMPLEQ_FOREACH(rtr, &conf->rtrs, entry)for((rtr) = ((&conf->rtrs)->sqh_first); (rtr) != (( void *)0); (rtr) = ((rtr)->entry.sqe_next)) { | |||
| 731 | if (imsg_compose(ibuf_rtr, IMSG_RECONF_RTR_CONFIG, rtr->id, | |||
| 732 | 0, -1, rtr->descr, sizeof(rtr->descr)) == -1) | |||
| 733 | return (-1); | |||
| 734 | } | |||
| 735 | ||||
| 736 | /* as-sets for filters in the RDE */ | |||
| 737 | while ((aset = SIMPLEQ_FIRST(&conf->as_sets)((&conf->as_sets)->sqh_first)) != NULL((void *)0)) { | |||
| 738 | struct ibuf *wbuf; | |||
| 739 | uint32_t *as; | |||
| 740 | size_t i, l, n; | |||
| 741 | ||||
| 742 | SIMPLEQ_REMOVE_HEAD(&conf->as_sets, entry)do { if (((&conf->as_sets)->sqh_first = (&conf-> as_sets)->sqh_first->entry.sqe_next) == ((void *)0)) (& conf->as_sets)->sqh_last = &(&conf->as_sets) ->sqh_first; } while (0); | |||
| 743 | ||||
| 744 | as = set_get(aset->set, &n); | |||
| 745 | if ((wbuf = imsg_create(ibuf_rde, IMSG_RECONF_AS_SET, 0, 0, | |||
| 746 | sizeof(n) + sizeof(aset->name))) == NULL((void *)0)) | |||
| 747 | return -1; | |||
| 748 | if (imsg_add(wbuf, &n, sizeof(n)) == -1 || | |||
| 749 | imsg_add(wbuf, aset->name, sizeof(aset->name)) == -1) | |||
| 750 | return -1; | |||
| 751 | imsg_close(ibuf_rde, wbuf); | |||
| 752 | ||||
| 753 | for (i = 0; i < n; i += l) { | |||
| 754 | l = (n - i > 1024 ? 1024 : n - i); | |||
| 755 | if (imsg_compose(ibuf_rde, IMSG_RECONF_AS_SET_ITEMS, | |||
| 756 | 0, 0, -1, as + i, l * sizeof(*as)) == -1) | |||
| 757 | return -1; | |||
| 758 | } | |||
| 759 | ||||
| 760 | if (imsg_compose(ibuf_rde, IMSG_RECONF_AS_SET_DONE, 0, 0, -1, | |||
| 761 | NULL((void *)0), 0) == -1) | |||
| 762 | return -1; | |||
| 763 | ||||
| 764 | set_free(aset->set); | |||
| 765 | free(aset); | |||
| 766 | } | |||
| 767 | ||||
| 768 | /* filters for the RDE */ | |||
| 769 | while ((r = TAILQ_FIRST(conf->filters)((conf->filters)->tqh_first)) != NULL((void *)0)) { | |||
| 770 | TAILQ_REMOVE(conf->filters, r, entry)do { if (((r)->entry.tqe_next) != ((void *)0)) (r)->entry .tqe_next->entry.tqe_prev = (r)->entry.tqe_prev; else ( conf->filters)->tqh_last = (r)->entry.tqe_prev; *(r) ->entry.tqe_prev = (r)->entry.tqe_next; ; ; } while (0); | |||
| 771 | if (send_filterset(ibuf_rde, &r->set) == -1) | |||
| 772 | return (-1); | |||
| 773 | if (imsg_compose(ibuf_rde, IMSG_RECONF_FILTER, 0, 0, -1, | |||
| 774 | r, sizeof(struct filter_rule)) == -1) | |||
| 775 | return (-1); | |||
| 776 | filterset_free(&r->set); | |||
| 777 | free(r); | |||
| 778 | } | |||
| 779 | ||||
| 780 | while ((vpn = SIMPLEQ_FIRST(&conf->l3vpns)((&conf->l3vpns)->sqh_first)) != NULL((void *)0)) { | |||
| 781 | SIMPLEQ_REMOVE_HEAD(&conf->l3vpns, entry)do { if (((&conf->l3vpns)->sqh_first = (&conf-> l3vpns)->sqh_first->entry.sqe_next) == ((void *)0)) (& conf->l3vpns)->sqh_last = &(&conf->l3vpns)-> sqh_first; } while (0); | |||
| 782 | if (ktable_update(vpn->rtableid, vpn->descr, vpn->flags) == | |||
| 783 | -1) { | |||
| 784 | log_warnx("failed to load routing table %d", | |||
| 785 | vpn->rtableid); | |||
| 786 | return (-1); | |||
| 787 | } | |||
| 788 | /* networks go via kroute to the RDE */ | |||
| 789 | kr_net_reload(vpn->rtableid, vpn->rd, &vpn->net_l); | |||
| 790 | ||||
| 791 | if (imsg_compose(ibuf_rde, IMSG_RECONF_VPN, 0, 0, -1, | |||
| 792 | vpn, sizeof(*vpn)) == -1) | |||
| 793 | return (-1); | |||
| 794 | ||||
| 795 | /* export targets */ | |||
| 796 | if (send_filterset(ibuf_rde, &vpn->export) == -1) | |||
| 797 | return (-1); | |||
| 798 | if (imsg_compose(ibuf_rde, IMSG_RECONF_VPN_EXPORT, 0, 0, | |||
| 799 | -1, NULL((void *)0), 0) == -1) | |||
| 800 | return (-1); | |||
| 801 | filterset_free(&vpn->export); | |||
| 802 | ||||
| 803 | /* import targets */ | |||
| 804 | if (send_filterset(ibuf_rde, &vpn->import) == -1) | |||
| 805 | return (-1); | |||
| 806 | if (imsg_compose(ibuf_rde, IMSG_RECONF_VPN_IMPORT, 0, 0, | |||
| 807 | -1, NULL((void *)0), 0) == -1) | |||
| 808 | return (-1); | |||
| 809 | filterset_free(&vpn->import); | |||
| 810 | ||||
| 811 | if (imsg_compose(ibuf_rde, IMSG_RECONF_VPN_DONE, 0, 0, | |||
| 812 | -1, NULL((void *)0), 0) == -1) | |||
| 813 | return (-1); | |||
| 814 | ||||
| 815 | free(vpn); | |||
| 816 | } | |||
| 817 | ||||
| 818 | /* send a drain message to know when all messages where processed */ | |||
| 819 | if (imsg_compose(ibuf_se, IMSG_RECONF_DRAIN, 0, 0, -1, NULL((void *)0), 0) == -1) | |||
| 820 | return (-1); | |||
| 821 | if (imsg_compose(ibuf_rde, IMSG_RECONF_DRAIN, 0, 0, -1, NULL((void *)0), 0) == -1) | |||
| 822 | return (-1); | |||
| 823 | if (imsg_compose(ibuf_rtr, IMSG_RECONF_DRAIN, 0, 0, -1, NULL((void *)0), 0) == -1) | |||
| 824 | return (-1); | |||
| 825 | ||||
| 826 | /* mrt changes can be sent out of bound */ | |||
| 827 | mrt_reconfigure(conf->mrt); | |||
| 828 | return (0); | |||
| 829 | } | |||
| 830 | ||||
| 831 | int | |||
| 832 | dispatch_imsg(struct imsgbuf *imsgbuf, int idx, struct bgpd_config *conf) | |||
| 833 | { | |||
| 834 | struct imsg imsg; | |||
| 835 | struct peer *p; | |||
| 836 | struct rtr_config *r; | |||
| 837 | struct kroute_full kf; | |||
| 838 | struct bgpd_addr addr; | |||
| 839 | struct pftable_msg pfmsg; | |||
| 840 | struct demote_msg demote; | |||
| 841 | char reason[REASON_LEN256], ifname[IFNAMSIZ16]; | |||
| 842 | ssize_t n; | |||
| 843 | u_int rtableid; | |||
| 844 | int rv, verbose; | |||
| 845 | ||||
| 846 | rv = 0; | |||
| 847 | while (imsgbuf) { | |||
| 848 | if ((n = imsg_get(imsgbuf, &imsg)) == -1) | |||
| 849 | return (-1); | |||
| 850 | ||||
| 851 | if (n == 0) | |||
| 852 | break; | |||
| 853 | ||||
| 854 | switch (imsg_get_type(&imsg)) { | |||
| 855 | case IMSG_KROUTE_CHANGE: | |||
| 856 | if (idx != PFD_PIPE_RDE1) | |||
| 857 | log_warnx("route request not from RDE"); | |||
| 858 | else if (imsg_get_data(&imsg, &kf, sizeof(kf)) == -1) | |||
| 859 | log_warn("wrong imsg len"); | |||
| 860 | else if (kr_change(imsg_get_id(&imsg), &kf)) | |||
| 861 | rv = -1; | |||
| 862 | break; | |||
| 863 | case IMSG_KROUTE_DELETE: | |||
| 864 | if (idx != PFD_PIPE_RDE1) | |||
| 865 | log_warnx("route request not from RDE"); | |||
| 866 | else if (imsg_get_data(&imsg, &kf, sizeof(kf)) == -1) | |||
| 867 | log_warn("wrong imsg len"); | |||
| 868 | else if (kr_delete(imsg_get_id(&imsg), &kf)) | |||
| 869 | rv = -1; | |||
| 870 | break; | |||
| 871 | case IMSG_KROUTE_FLUSH: | |||
| 872 | if (idx != PFD_PIPE_RDE1) | |||
| 873 | log_warnx("route request not from RDE"); | |||
| 874 | else if (kr_flush(imsg_get_id(&imsg))) | |||
| 875 | rv = -1; | |||
| 876 | break; | |||
| 877 | case IMSG_NEXTHOP_ADD: | |||
| 878 | if (idx != PFD_PIPE_RDE1) | |||
| 879 | log_warnx("nexthop request not from RDE"); | |||
| 880 | else if (imsg_get_data(&imsg, &addr, sizeof(addr)) == | |||
| 881 | -1) | |||
| 882 | log_warn("wrong imsg len"); | |||
| 883 | else { | |||
| 884 | rtableid = conf->default_tableid; | |||
| 885 | if (kr_nexthop_add(rtableid, &addr) == -1) | |||
| 886 | rv = -1; | |||
| 887 | } | |||
| 888 | break; | |||
| 889 | case IMSG_NEXTHOP_REMOVE: | |||
| 890 | if (idx != PFD_PIPE_RDE1) | |||
| 891 | log_warnx("nexthop request not from RDE"); | |||
| 892 | else if (imsg_get_data(&imsg, &addr, sizeof(addr)) == | |||
| 893 | -1) | |||
| 894 | log_warn("wrong imsg len"); | |||
| 895 | else { | |||
| 896 | rtableid = conf->default_tableid; | |||
| 897 | kr_nexthop_delete(rtableid, &addr); | |||
| 898 | } | |||
| 899 | break; | |||
| 900 | case IMSG_PFTABLE_ADD: | |||
| 901 | if (idx != PFD_PIPE_RDE1) | |||
| 902 | log_warnx("pftable request not from RDE"); | |||
| 903 | else if (imsg_get_data(&imsg, &pfmsg, sizeof(pfmsg)) == | |||
| 904 | -1) | |||
| 905 | log_warn("wrong imsg len"); | |||
| 906 | else if (pftable_addr_add(&pfmsg) != 0) | |||
| 907 | rv = -1; | |||
| 908 | break; | |||
| 909 | case IMSG_PFTABLE_REMOVE: | |||
| 910 | if (idx != PFD_PIPE_RDE1) | |||
| 911 | log_warnx("pftable request not from RDE"); | |||
| 912 | else if (imsg_get_data(&imsg, &pfmsg, sizeof(pfmsg)) == | |||
| 913 | -1) | |||
| 914 | log_warn("wrong imsg len"); | |||
| 915 | else if (pftable_addr_remove(&pfmsg) != 0) | |||
| 916 | rv = -1; | |||
| 917 | break; | |||
| 918 | case IMSG_PFTABLE_COMMIT: | |||
| 919 | if (idx != PFD_PIPE_RDE1) | |||
| 920 | log_warnx("pftable request not from RDE"); | |||
| 921 | else if (pftable_commit() != 0) | |||
| 922 | rv = -1; | |||
| 923 | break; | |||
| 924 | case IMSG_PFKEY_RELOAD: | |||
| 925 | if (idx != PFD_PIPE_SESSION0) { | |||
| 926 | log_warnx("pfkey reload request not from SE"); | |||
| 927 | break; | |||
| 928 | } | |||
| 929 | p = getpeerbyid(conf, imsg_get_id(&imsg)); | |||
| 930 | if (p != NULL((void *)0)) { | |||
| 931 | if (pfkey_establish(p) == -1) | |||
| 932 | log_peer_warnx(&p->conf, | |||
| 933 | "pfkey setup failed"); | |||
| 934 | } | |||
| 935 | break; | |||
| 936 | case IMSG_CTL_RELOAD: | |||
| 937 | if (idx != PFD_PIPE_SESSION0) | |||
| 938 | log_warnx("reload request not from SE"); | |||
| 939 | else { | |||
| 940 | reconfig = 1; | |||
| 941 | reconfpid = imsg_get_pid(&imsg); | |||
| 942 | if (imsg_get_data(&imsg, reason, | |||
| 943 | sizeof(reason)) == 0 && reason[0] != '\0') | |||
| 944 | log_info("reload due to: %s", | |||
| 945 | log_reason(reason)); | |||
| 946 | } | |||
| 947 | break; | |||
| 948 | case IMSG_CTL_FIB_COUPLE: | |||
| 949 | if (idx != PFD_PIPE_SESSION0) | |||
| 950 | log_warnx("couple request not from SE"); | |||
| 951 | else | |||
| 952 | kr_fib_couple(imsg_get_id(&imsg)); | |||
| 953 | break; | |||
| 954 | case IMSG_CTL_FIB_DECOUPLE: | |||
| 955 | if (idx != PFD_PIPE_SESSION0) | |||
| 956 | log_warnx("decouple request not from SE"); | |||
| 957 | else | |||
| 958 | kr_fib_decouple(imsg_get_id(&imsg)); | |||
| 959 | break; | |||
| 960 | case IMSG_CTL_KROUTE: | |||
| 961 | case IMSG_CTL_KROUTE_ADDR: | |||
| 962 | case IMSG_CTL_SHOW_NEXTHOP: | |||
| 963 | case IMSG_CTL_SHOW_INTERFACE: | |||
| 964 | case IMSG_CTL_SHOW_FIB_TABLES: | |||
| 965 | if (idx != PFD_PIPE_SESSION0) | |||
| 966 | log_warnx("kroute request not from SE"); | |||
| 967 | else | |||
| 968 | kr_show_route(&imsg); | |||
| 969 | break; | |||
| 970 | case IMSG_SESSION_DEPENDON: | |||
| 971 | if (idx != PFD_PIPE_SESSION0) | |||
| 972 | log_warnx("DEPENDON request not from SE"); | |||
| 973 | else if (imsg_get_data(&imsg, ifname, sizeof(ifname)) == | |||
| 974 | -1) | |||
| 975 | log_warn("wrong imsg len"); | |||
| 976 | else | |||
| 977 | kr_ifinfo(ifname); | |||
| 978 | break; | |||
| 979 | case IMSG_DEMOTE: | |||
| 980 | if (idx != PFD_PIPE_SESSION0) | |||
| 981 | log_warnx("demote request not from SE"); | |||
| 982 | else if (imsg_get_data(&imsg, &demote, sizeof(demote)) | |||
| 983 | == -1) | |||
| 984 | log_warn("wrong imsg len"); | |||
| 985 | else | |||
| 986 | carp_demote_set(demote.demote_group, | |||
| 987 | demote.level); | |||
| 988 | break; | |||
| 989 | case IMSG_CTL_LOG_VERBOSE: | |||
| 990 | /* already checked by SE */ | |||
| 991 | if (imsg_get_data(&imsg, &verbose, sizeof(verbose)) == | |||
| 992 | -1) | |||
| 993 | log_warn("wrong imsg len"); | |||
| 994 | else | |||
| 995 | log_setverbose(verbose); | |||
| 996 | break; | |||
| 997 | case IMSG_RECONF_DONE: | |||
| 998 | if (reconfpending == 0) { | |||
| 999 | log_warnx("unexpected RECONF_DONE received"); | |||
| 1000 | break; | |||
| 1001 | } | |||
| 1002 | if (idx == PFD_PIPE_SESSION0) { | |||
| 1003 | /* RDE and RTR engine can reload concurrently */ | |||
| 1004 | imsg_compose(ibuf_rtr, IMSG_RECONF_DONE, 0, | |||
| 1005 | 0, -1, NULL((void *)0), 0); | |||
| 1006 | imsg_compose(ibuf_rde, IMSG_RECONF_DONE, 0, | |||
| 1007 | 0, -1, NULL((void *)0), 0); | |||
| 1008 | ||||
| 1009 | /* finally fix kroute information */ | |||
| 1010 | ktable_postload(); | |||
| 1011 | ||||
| 1012 | /* redistribute list needs to be reloaded too */ | |||
| 1013 | kr_reload(); | |||
| 1014 | } | |||
| 1015 | reconfpending--; | |||
| 1016 | break; | |||
| 1017 | case IMSG_RECONF_DRAIN: | |||
| 1018 | if (reconfpending == 0) { | |||
| 1019 | log_warnx("unexpected RECONF_DRAIN received"); | |||
| 1020 | break; | |||
| 1021 | } | |||
| 1022 | reconfpending--; | |||
| 1023 | if (reconfpending == 0) { | |||
| 1024 | /* | |||
| 1025 | * SE goes first to bring templated neighbors | |||
| 1026 | * in sync. | |||
| 1027 | */ | |||
| 1028 | imsg_compose(ibuf_se, IMSG_RECONF_DONE, 0, | |||
| 1029 | 0, -1, NULL((void *)0), 0); | |||
| 1030 | reconfpending = 3; /* expecting 2 DONE msg */ | |||
| 1031 | } | |||
| 1032 | break; | |||
| 1033 | case IMSG_SOCKET_CONN: | |||
| 1034 | if (idx != PFD_PIPE_RTR2) { | |||
| 1035 | log_warnx("connect request not from RTR"); | |||
| 1036 | } else { | |||
| 1037 | SIMPLEQ_FOREACH(r, &conf->rtrs, entry)for((r) = ((&conf->rtrs)->sqh_first); (r) != ((void *)0); (r) = ((r)->entry.sqe_next)) { | |||
| 1038 | if (imsg_get_id(&imsg) == r->id) | |||
| 1039 | break; | |||
| 1040 | } | |||
| 1041 | if (r == NULL((void *)0)) | |||
| 1042 | log_warnx("unknown rtr id %d", | |||
| 1043 | imsg_get_id(&imsg)); | |||
| 1044 | else | |||
| 1045 | bgpd_rtr_connect(r); | |||
| 1046 | } | |||
| 1047 | break; | |||
| 1048 | case IMSG_CTL_SHOW_RTR: | |||
| 1049 | if (idx == PFD_PIPE_SESSION0) { | |||
| 1050 | SIMPLEQ_FOREACH(r, &conf->rtrs, entry)for((r) = ((&conf->rtrs)->sqh_first); (r) != ((void *)0); (r) = ((r)->entry.sqe_next)) { | |||
| 1051 | imsg_compose(ibuf_rtr, | |||
| 1052 | IMSG_CTL_SHOW_RTR, r->id, | |||
| 1053 | imsg_get_pid(&imsg), -1, NULL((void *)0), 0); | |||
| 1054 | } | |||
| 1055 | imsg_compose(ibuf_rtr, IMSG_CTL_END, | |||
| 1056 | 0, imsg_get_pid(&imsg), -1, NULL((void *)0), 0); | |||
| 1057 | } else if (idx == PFD_PIPE_RTR2) { | |||
| 1058 | struct ctl_show_rtr rtr; | |||
| 1059 | if (imsg_get_data(&imsg, &rtr, sizeof(rtr)) == | |||
| 1060 | -1) { | |||
| 1061 | log_warn("wrong imsg len"); | |||
| 1062 | break; | |||
| 1063 | } | |||
| 1064 | ||||
| 1065 | SIMPLEQ_FOREACH(r, &conf->rtrs, entry)for((r) = ((&conf->rtrs)->sqh_first); (r) != ((void *)0); (r) = ((r)->entry.sqe_next)) { | |||
| 1066 | if (imsg_get_id(&imsg) == r->id) | |||
| 1067 | break; | |||
| 1068 | } | |||
| 1069 | if (r != NULL((void *)0)) { | |||
| 1070 | strlcpy(rtr.descr, r->descr, | |||
| 1071 | sizeof(rtr.descr)); | |||
| 1072 | rtr.local_addr = r->local_addr; | |||
| 1073 | rtr.remote_addr = r->remote_addr; | |||
| 1074 | rtr.remote_port = r->remote_port; | |||
| 1075 | ||||
| 1076 | imsg_compose(ibuf_se, IMSG_CTL_SHOW_RTR, | |||
| 1077 | imsg_get_id(&imsg), | |||
| 1078 | imsg_get_pid(&imsg), -1, | |||
| 1079 | &rtr, sizeof(rtr)); | |||
| 1080 | } | |||
| 1081 | } | |||
| 1082 | break; | |||
| 1083 | case IMSG_CTL_END: | |||
| 1084 | case IMSG_CTL_SHOW_TIMER: | |||
| 1085 | if (idx != PFD_PIPE_RTR2) { | |||
| 1086 | log_warnx("connect request not from RTR"); | |||
| 1087 | break; | |||
| 1088 | } | |||
| 1089 | imsg_forward(ibuf_se, &imsg); | |||
| 1090 | break; | |||
| 1091 | default: | |||
| 1092 | break; | |||
| 1093 | } | |||
| 1094 | imsg_free(&imsg); | |||
| 1095 | if (rv != 0) | |||
| 1096 | return (rv); | |||
| 1097 | } | |||
| 1098 | return (0); | |||
| 1099 | } | |||
| 1100 | ||||
| 1101 | void | |||
| 1102 | send_nexthop_update(struct kroute_nexthop *msg) | |||
| 1103 | { | |||
| 1104 | char *gw = NULL((void *)0); | |||
| 1105 | ||||
| 1106 | if (msg->gateway.aid) | |||
| 1107 | if (asprintf(&gw, ": via %s", | |||
| 1108 | log_addr(&msg->gateway)) == -1) { | |||
| 1109 | log_warn("send_nexthop_update"); | |||
| 1110 | quit = 1; | |||
| 1111 | } | |||
| 1112 | ||||
| 1113 | log_debug("nexthop %s now %s%s%s", log_addr(&msg->nexthop), | |||
| 1114 | msg->valid ? "valid" : "invalid", | |||
| 1115 | msg->connected ? ": directly connected" : "", | |||
| 1116 | msg->gateway.aid ? gw : ""); | |||
| 1117 | ||||
| 1118 | free(gw); | |||
| 1119 | ||||
| 1120 | if (imsg_compose(ibuf_rde, IMSG_NEXTHOP_UPDATE, 0, 0, -1, | |||
| 1121 | msg, sizeof(struct kroute_nexthop)) == -1) | |||
| 1122 | quit = 1; | |||
| 1123 | } | |||
| 1124 | ||||
| 1125 | void | |||
| 1126 | send_imsg_session(int type, pid_t pid, void *data, uint16_t datalen) | |||
| 1127 | { | |||
| 1128 | imsg_compose(ibuf_se, type, 0, pid, -1, data, datalen); | |||
| 1129 | } | |||
| 1130 | ||||
| 1131 | int | |||
| 1132 | send_network(int type, struct network_config *net, struct filter_set_head *h) | |||
| 1133 | { | |||
| 1134 | if (quit) | |||
| 1135 | return (0); | |||
| 1136 | if (imsg_compose(ibuf_rde, type, 0, 0, -1, net, | |||
| 1137 | sizeof(struct network_config)) == -1) | |||
| 1138 | return (-1); | |||
| 1139 | /* networks that get deleted don't need to send the filter set */ | |||
| 1140 | if (type == IMSG_NETWORK_REMOVE) | |||
| 1141 | return (0); | |||
| 1142 | if (send_filterset(ibuf_rde, h) == -1) | |||
| 1143 | return (-1); | |||
| 1144 | if (imsg_compose(ibuf_rde, IMSG_NETWORK_DONE, 0, 0, -1, NULL((void *)0), 0) == -1) | |||
| 1145 | return (-1); | |||
| 1146 | ||||
| 1147 | return (0); | |||
| 1148 | } | |||
| 1149 | ||||
| 1150 | /* | |||
| 1151 | * Return true if a route can be used for nexthop resolution. | |||
| 1152 | */ | |||
| 1153 | int | |||
| 1154 | bgpd_oknexthop(struct kroute_full *kf) | |||
| 1155 | { | |||
| 1156 | if (kf->flags & F_BGPD0x0001) | |||
| 1157 | return ((cflags & BGPD_FLAG_NEXTHOP_BGP0x0010) != 0); | |||
| 1158 | ||||
| 1159 | if (kf->prefixlen == 0) | |||
| 1160 | return ((cflags & BGPD_FLAG_NEXTHOP_DEFAULT0x0020) != 0); | |||
| 1161 | ||||
| 1162 | /* any other route is fine */ | |||
| 1163 | return (1); | |||
| 1164 | } | |||
| 1165 | ||||
| 1166 | int | |||
| 1167 | control_setup(struct bgpd_config *conf) | |||
| 1168 | { | |||
| 1169 | int fd, restricted; | |||
| 1170 | ||||
| 1171 | /* control socket is outside chroot */ | |||
| 1172 | if (!cname || strcmp(cname, conf->csock)) { | |||
| 1173 | if (cname) { | |||
| 1174 | free(cname); | |||
| 1175 | } | |||
| 1176 | if ((cname = strdup(conf->csock)) == NULL((void *)0)) | |||
| 1177 | fatal("strdup"); | |||
| 1178 | if (control_check(cname) == -1) | |||
| 1179 | return (-1); | |||
| 1180 | if ((fd = control_init(0, cname)) == -1) | |||
| 1181 | fatalx("control socket setup failed"); | |||
| 1182 | if (control_listen(fd) == -1) | |||
| 1183 | fatalx("control socket setup failed"); | |||
| 1184 | restricted = 0; | |||
| 1185 | if (imsg_compose(ibuf_se, IMSG_RECONF_CTRL, 0, 0, fd, | |||
| 1186 | &restricted, sizeof(restricted)) == -1) | |||
| 1187 | return (-1); | |||
| 1188 | } | |||
| 1189 | if (!conf->rcsock) { | |||
| 1190 | /* remove restricted socket */ | |||
| 1191 | free(rcname); | |||
| 1192 | rcname = NULL((void *)0); | |||
| 1193 | } else if (!rcname || strcmp(rcname, conf->rcsock)) { | |||
| 1194 | if (rcname) { | |||
| 1195 | free(rcname); | |||
| 1196 | } | |||
| 1197 | if ((rcname = strdup(conf->rcsock)) == NULL((void *)0)) | |||
| 1198 | fatal("strdup"); | |||
| 1199 | if (control_check(rcname) == -1) | |||
| 1200 | return (-1); | |||
| 1201 | if ((fd = control_init(1, rcname)) == -1) | |||
| 1202 | fatalx("control socket setup failed"); | |||
| 1203 | if (control_listen(fd) == -1) | |||
| 1204 | fatalx("control socket setup failed"); | |||
| 1205 | restricted = 1; | |||
| 1206 | if (imsg_compose(ibuf_se, IMSG_RECONF_CTRL, 0, 0, fd, | |||
| 1207 | &restricted, sizeof(restricted)) == -1) | |||
| 1208 | return (-1); | |||
| 1209 | } | |||
| 1210 | return (0); | |||
| 1211 | } | |||
| 1212 | ||||
| 1213 | void | |||
| 1214 | set_pollfd(struct pollfd *pfd, struct imsgbuf *i) | |||
| 1215 | { | |||
| 1216 | if (i == NULL((void *)0) || i->fd == -1) { | |||
| 1217 | pfd->fd = -1; | |||
| 1218 | return; | |||
| 1219 | } | |||
| 1220 | pfd->fd = i->fd; | |||
| 1221 | pfd->events = POLLIN0x0001; | |||
| 1222 | if (i->w.queued > 0) | |||
| 1223 | pfd->events |= POLLOUT0x0004; | |||
| 1224 | } | |||
| 1225 | ||||
| 1226 | int | |||
| 1227 | handle_pollfd(struct pollfd *pfd, struct imsgbuf *i) | |||
| 1228 | { | |||
| 1229 | ssize_t n; | |||
| 1230 | ||||
| 1231 | if (i == NULL((void *)0)) | |||
| 1232 | return (0); | |||
| 1233 | ||||
| 1234 | if (pfd->revents & POLLOUT0x0004) | |||
| 1235 | if (msgbuf_write(&i->w) <= 0 && errno(*__errno()) != EAGAIN35) { | |||
| 1236 | log_warn("imsg write error"); | |||
| 1237 | close(i->fd); | |||
| 1238 | i->fd = -1; | |||
| 1239 | return (-1); | |||
| 1240 | } | |||
| 1241 | ||||
| 1242 | if (pfd->revents & POLLIN0x0001) { | |||
| 1243 | if ((n = imsg_read(i)) == -1 && errno(*__errno()) != EAGAIN35) { | |||
| 1244 | log_warn("imsg read error"); | |||
| 1245 | close(i->fd); | |||
| 1246 | i->fd = -1; | |||
| 1247 | return (-1); | |||
| 1248 | } | |||
| 1249 | if (n == 0) { | |||
| 1250 | log_warnx("peer closed imsg connection"); | |||
| 1251 | close(i->fd); | |||
| 1252 | i->fd = -1; | |||
| 1253 | return (-1); | |||
| 1254 | } | |||
| 1255 | } | |||
| 1256 | return (0); | |||
| 1257 | } | |||
| 1258 | ||||
| 1259 | static void | |||
| 1260 | getsockpair(int pipe[2]) | |||
| 1261 | { | |||
| 1262 | int bsize, i; | |||
| 1263 | ||||
| 1264 | if (socketpair(AF_UNIX1, SOCK_STREAM1 | SOCK_CLOEXEC0x8000 | SOCK_NONBLOCK0x4000, | |||
| 1265 | PF_UNSPEC0, pipe) == -1) | |||
| 1266 | fatal("socketpair"); | |||
| 1267 | ||||
| 1268 | for (i = 0; i < 2; i++) { | |||
| 1269 | for (bsize = MAX_SOCK_BUF(4 * 65535); bsize >= 16 * 1024; bsize /= 2) { | |||
| 1270 | if (setsockopt(pipe[i], SOL_SOCKET0xffff, SO_RCVBUF0x1002, | |||
| 1271 | &bsize, sizeof(bsize)) == -1) { | |||
| 1272 | if (errno(*__errno()) != ENOBUFS55) | |||
| 1273 | fatal("setsockopt(SO_RCVBUF, %d)", | |||
| 1274 | bsize); | |||
| 1275 | log_warn("setsockopt(SO_RCVBUF, %d)", bsize); | |||
| 1276 | continue; | |||
| 1277 | } | |||
| 1278 | break; | |||
| 1279 | } | |||
| 1280 | } | |||
| 1281 | for (i = 0; i < 2; i++) { | |||
| 1282 | for (bsize = MAX_SOCK_BUF(4 * 65535); bsize >= 16 * 1024; bsize /= 2) { | |||
| 1283 | if (setsockopt(pipe[i], SOL_SOCKET0xffff, SO_SNDBUF0x1001, | |||
| 1284 | &bsize, sizeof(bsize)) == -1) { | |||
| 1285 | if (errno(*__errno()) != ENOBUFS55) | |||
| 1286 | fatal("setsockopt(SO_SNDBUF, %d)", | |||
| 1287 | bsize); | |||
| 1288 | log_warn("setsockopt(SO_SNDBUF, %d)", bsize); | |||
| 1289 | continue; | |||
| 1290 | } | |||
| 1291 | break; | |||
| 1292 | } | |||
| 1293 | } | |||
| 1294 | } | |||
| 1295 | ||||
| 1296 | int | |||
| 1297 | imsg_send_sockets(struct imsgbuf *se, struct imsgbuf *rde, struct imsgbuf *rtr) | |||
| 1298 | { | |||
| 1299 | int pipe_s2r[2]; | |||
| 1300 | int pipe_s2r_ctl[2]; | |||
| 1301 | int pipe_r2r[2]; | |||
| 1302 | ||||
| 1303 | getsockpair(pipe_s2r); | |||
| 1304 | getsockpair(pipe_s2r_ctl); | |||
| 1305 | getsockpair(pipe_r2r); | |||
| 1306 | ||||
| 1307 | if (imsg_compose(se, IMSG_SOCKET_CONN, 0, 0, pipe_s2r[0], | |||
| 1308 | NULL((void *)0), 0) == -1) | |||
| 1309 | return (-1); | |||
| 1310 | if (imsg_compose(rde, IMSG_SOCKET_CONN, 0, 0, pipe_s2r[1], | |||
| 1311 | NULL((void *)0), 0) == -1) | |||
| 1312 | return (-1); | |||
| 1313 | ||||
| 1314 | if (imsg_compose(se, IMSG_SOCKET_CONN_CTL, 0, 0, pipe_s2r_ctl[0], | |||
| 1315 | NULL((void *)0), 0) == -1) | |||
| 1316 | return (-1); | |||
| 1317 | if (imsg_compose(rde, IMSG_SOCKET_CONN_CTL, 0, 0, pipe_s2r_ctl[1], | |||
| 1318 | NULL((void *)0), 0) == -1) | |||
| 1319 | return (-1); | |||
| 1320 | ||||
| 1321 | if (imsg_compose(rtr, IMSG_SOCKET_CONN_RTR, 0, 0, pipe_r2r[0], | |||
| 1322 | NULL((void *)0), 0) == -1) | |||
| 1323 | return (-1); | |||
| 1324 | if (imsg_compose(rde, IMSG_SOCKET_CONN_RTR, 0, 0, pipe_r2r[1], | |||
| 1325 | NULL((void *)0), 0) == -1) | |||
| 1326 | return (-1); | |||
| 1327 | ||||
| 1328 | return (0); | |||
| 1329 | } | |||
| 1330 | ||||
| 1331 | void | |||
| 1332 | bgpd_rtr_connect(struct rtr_config *r) | |||
| 1333 | { | |||
| 1334 | struct connect_elm *ce; | |||
| 1335 | struct sockaddr *sa; | |||
| 1336 | socklen_t len; | |||
| 1337 | ||||
| 1338 | if (connect_cnt >= MAX_CONNECT_CNT32) { | |||
| 1339 | log_warnx("rtr %s: too many concurrent connection requests", | |||
| 1340 | r->descr); | |||
| 1341 | return; | |||
| 1342 | } | |||
| 1343 | ||||
| 1344 | if ((ce = calloc(1, sizeof(*ce))) == NULL((void *)0)) { | |||
| 1345 | log_warn("rtr %s", r->descr); | |||
| 1346 | return; | |||
| 1347 | } | |||
| 1348 | ||||
| 1349 | ce->id = r->id; | |||
| 1350 | ce->fd = socket(aid2af(r->remote_addr.aid), | |||
| 1351 | SOCK_STREAM1 | SOCK_CLOEXEC0x8000 | SOCK_NONBLOCK0x4000, IPPROTO_TCP6); | |||
| 1352 | if (ce->fd == -1) { | |||
| 1353 | log_warn("rtr %s", r->descr); | |||
| 1354 | free(ce); | |||
| 1355 | return; | |||
| 1356 | } | |||
| 1357 | ||||
| 1358 | if ((sa = addr2sa(&r->local_addr, 0, &len)) != NULL((void *)0)) { | |||
| 1359 | if (bind(ce->fd, sa, len) == -1) { | |||
| 1360 | log_warn("rtr %s: bind to %s", r->descr, | |||
| 1361 | log_addr(&r->local_addr)); | |||
| 1362 | close(ce->fd); | |||
| 1363 | free(ce); | |||
| 1364 | return; | |||
| 1365 | } | |||
| 1366 | } | |||
| 1367 | ||||
| 1368 | sa = addr2sa(&r->remote_addr, r->remote_port, &len); | |||
| 1369 | if (connect(ce->fd, sa, len) == -1) { | |||
| 1370 | if (errno(*__errno()) != EINPROGRESS36) { | |||
| 1371 | log_warn("rtr %s: connect to %s:%u", r->descr, | |||
| 1372 | log_addr(&r->remote_addr), r->remote_port); | |||
| 1373 | close(ce->fd); | |||
| 1374 | free(ce); | |||
| 1375 | return; | |||
| 1376 | } | |||
| 1377 | TAILQ_INSERT_TAIL(&connect_queue, ce, entry)do { (ce)->entry.tqe_next = ((void *)0); (ce)->entry.tqe_prev = (&connect_queue)->tqh_last; *(&connect_queue)-> tqh_last = (ce); (&connect_queue)->tqh_last = &(ce )->entry.tqe_next; } while (0); | |||
| 1378 | connect_cnt++; | |||
| 1379 | return; | |||
| 1380 | } | |||
| 1381 | ||||
| 1382 | imsg_compose(ibuf_rtr, IMSG_SOCKET_CONN, ce->id, 0, ce->fd, NULL((void *)0), 0); | |||
| 1383 | free(ce); | |||
| 1384 | } | |||
| 1385 | ||||
| 1386 | void | |||
| 1387 | bgpd_rtr_connect_done(int fd, struct bgpd_config *conf) | |||
| 1388 | { | |||
| 1389 | struct rtr_config *r; | |||
| 1390 | struct connect_elm *ce; | |||
| 1391 | int error = 0; | |||
| 1392 | socklen_t len; | |||
| 1393 | ||||
| 1394 | TAILQ_FOREACH(ce, &connect_queue, entry)for((ce) = ((&connect_queue)->tqh_first); (ce) != ((void *)0); (ce) = ((ce)->entry.tqe_next)) { | |||
| 1395 | if (ce->fd == fd) | |||
| 1396 | break; | |||
| 1397 | } | |||
| 1398 | if (ce == NULL((void *)0)) | |||
| 1399 | fatalx("connect entry not found"); | |||
| 1400 | ||||
| 1401 | TAILQ_REMOVE(&connect_queue, ce, entry)do { if (((ce)->entry.tqe_next) != ((void *)0)) (ce)->entry .tqe_next->entry.tqe_prev = (ce)->entry.tqe_prev; else ( &connect_queue)->tqh_last = (ce)->entry.tqe_prev; * (ce)->entry.tqe_prev = (ce)->entry.tqe_next; ; ; } while (0); | |||
| 1402 | connect_cnt--; | |||
| 1403 | ||||
| 1404 | SIMPLEQ_FOREACH(r, &conf->rtrs, entry)for((r) = ((&conf->rtrs)->sqh_first); (r) != ((void *)0); (r) = ((r)->entry.sqe_next)) { | |||
| 1405 | if (ce->id == r->id) | |||
| 1406 | break; | |||
| 1407 | } | |||
| 1408 | if (r == NULL((void *)0)) { | |||
| 1409 | log_warnx("rtr id %d no longer exists", ce->id); | |||
| 1410 | goto fail; | |||
| 1411 | } | |||
| 1412 | ||||
| 1413 | len = sizeof(error); | |||
| 1414 | if (getsockopt(fd, SOL_SOCKET0xffff, SO_ERROR0x1007, &error, &len) == -1) { | |||
| 1415 | log_warn("rtr %s: getsockopt SO_ERROR", r->descr); | |||
| 1416 | goto fail; | |||
| 1417 | } | |||
| 1418 | ||||
| 1419 | if (error != 0) { | |||
| 1420 | errno(*__errno()) = error; | |||
| 1421 | log_warn("rtr %s: connect to %s:%u", r->descr, | |||
| 1422 | log_addr(&r->remote_addr), r->remote_port); | |||
| 1423 | goto fail; | |||
| 1424 | } | |||
| 1425 | ||||
| 1426 | imsg_compose(ibuf_rtr, IMSG_SOCKET_CONN, ce->id, 0, ce->fd, NULL((void *)0), 0); | |||
| 1427 | free(ce); | |||
| 1428 | return; | |||
| 1429 | ||||
| 1430 | fail: | |||
| 1431 | close(fd); | |||
| 1432 | free(ce); | |||
| 1433 | } |