diff options
Diffstat (limited to 'usr.sbin/ripd')
| -rw-r--r-- | usr.sbin/ripd/Makefile | 18 | ||||
| -rw-r--r-- | usr.sbin/ripd/auth.c | 295 | ||||
| -rw-r--r-- | usr.sbin/ripd/buffer.c | 218 | ||||
| -rw-r--r-- | usr.sbin/ripd/control.c | 300 | ||||
| -rw-r--r-- | usr.sbin/ripd/control.h | 50 | ||||
| -rw-r--r-- | usr.sbin/ripd/imsg.c | 178 | ||||
| -rw-r--r-- | usr.sbin/ripd/interface.c | 482 | ||||
| -rw-r--r-- | usr.sbin/ripd/kroute.c | 1126 | ||||
| -rw-r--r-- | usr.sbin/ripd/log.c | 222 | ||||
| -rw-r--r-- | usr.sbin/ripd/log.h | 35 | ||||
| -rw-r--r-- | usr.sbin/ripd/neighbor.c | 357 | ||||
| -rw-r--r-- | usr.sbin/ripd/packet.c | 251 | ||||
| -rw-r--r-- | usr.sbin/ripd/parse.y | 763 | ||||
| -rw-r--r-- | usr.sbin/ripd/printconf.c | 106 | ||||
| -rw-r--r-- | usr.sbin/ripd/rde.c | 455 | ||||
| -rw-r--r-- | usr.sbin/ripd/rde.h | 64 | ||||
| -rw-r--r-- | usr.sbin/ripd/rde_rib.c | 258 | ||||
| -rw-r--r-- | usr.sbin/ripd/rip.h | 82 | ||||
| -rw-r--r-- | usr.sbin/ripd/ripd.8 | 81 | ||||
| -rw-r--r-- | usr.sbin/ripd/ripd.conf.5 | 195 | ||||
| -rw-r--r-- | usr.sbin/ripd/ripd.h | 392 | ||||
| -rw-r--r-- | usr.sbin/ripd/ripe.c | 504 | ||||
| -rw-r--r-- | usr.sbin/ripd/ripe.h | 146 |
23 files changed, 6578 insertions, 0 deletions
diff --git a/usr.sbin/ripd/Makefile b/usr.sbin/ripd/Makefile new file mode 100644 index 00000000000..261abf70b56 --- /dev/null +++ b/usr.sbin/ripd/Makefile @@ -0,0 +1,18 @@ +# $OpenBSD: Makefile,v 1.1 2006/10/18 16:11:58 norby Exp $ + +PROG= ripd +SRCS= auth.c buffer.c control.c imsg.c interface.c kroute.c \ + log.c message.c neighbor.c packet.c parse.y printconf.c \ + rde.c rde_rib.c ripe.c ripd.c + +MAN= ripd.8 ripd.conf.5 + +CFLAGS+= -Wall -I${.CURDIR} +CFLAGS+= -Wstrict-prototypes -Wmissing-prototypes +CFLAGS+= -Wmissing-declarations +CFLAGS+= -Wshadow -Wpointer-arith -Wcast-qual +CFLAGS+= -Wsign-compare +YFLAGS= +LDADD+= -levent + +.include <bsd.prog.mk> diff --git a/usr.sbin/ripd/auth.c b/usr.sbin/ripd/auth.c new file mode 100644 index 00000000000..ae3a20b5891 --- /dev/null +++ b/usr.sbin/ripd/auth.c @@ -0,0 +1,295 @@ +/* $OpenBSD: auth.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/socket.h> +#include <limits.h> +#include <md5.h> +#include <stdlib.h> +#include <string.h> + +#include "ripd.h" +#include "rip.h" +#include "log.h" +#include "ripe.h" + +struct auth_md *md_list_find(struct auth_md_head *, u_int8_t); +void auth_trailer_header_gen(struct buf *); +u_int32_t auth_get_seq_num(void); + +u_int32_t +auth_get_seq_num() +{ + return time(NULL); +} + +void +auth_trailer_header_gen(struct buf *buf) +{ + u_int16_t field1 = 0xFFFF; + u_int16_t field2 = htons(0x01); + + buf_add(buf, &field1, sizeof(field1)); + buf_add(buf, &field2, sizeof(field2)); +} + +/* XXX add the support for key lifetime and rollover */ +int +auth_validate(char **buf, u_int16_t *len, struct iface *iface, struct nbr *nbr, + struct nbr_failed *nbr_failed, u_int32_t *crypt_seq_num) +{ + MD5_CTX hash; + u_int8_t digest[MD5_DIGEST_LENGTH]; + u_int8_t recv_digest[MD5_DIGEST_LENGTH]; + char pwd[MAX_SIMPLE_AUTH_LEN]; + struct rip_auth *auth_head; + struct md5_auth *a; + struct auth_md *md; + char *auth_data; + char *b = *buf; + + *buf += RIP_HDR_LEN; + *len -= RIP_HDR_LEN; + + auth_head = (struct rip_auth *)(*buf); + + if (auth_head->auth_fixed != AUTH) { + if (iface->auth_type != AUTH_NONE) { + log_debug("auth_validate: packet carrying no" + " authentication"); + return (-1); + } + return (0); + } else { + if (ntohs(auth_head->auth_type) != + (u_int16_t)iface->auth_type) { + log_debug("auth_validate: wrong auth type"); + return (-1); + } + } + + switch (iface->auth_type) { + case AUTH_SIMPLE: + bcopy(*buf+sizeof(*auth_head), pwd, MAX_SIMPLE_AUTH_LEN); + if (bcmp(pwd, iface->auth_key, MAX_SIMPLE_AUTH_LEN)) { + log_debug("auth_validate: wrong password, " + "interface: %s", iface->name); + return (-1); + } + break; + case AUTH_CRYPT: + a = (struct md5_auth *)(*buf + sizeof(*auth_head)); + + if ((md = md_list_find(&iface->auth_md_list, + a->auth_keyid)) == NULL) { + log_debug("auth_validate: keyid %d not configured, " + "interface %s", a->auth_keyid, + iface->name); + return (-1); + } + + if (nbr != NULL) { + if (ntohl(a->auth_seq) < nbr->auth_seq_num) { + log_debug("auth_validate: decreasing seq num, " + "interface %s", iface->name); + return (-1); + } + } else if (nbr_failed != NULL) { + if (ntohl(a->auth_seq) < nbr_failed->auth_seq_num && + ntohl(a->auth_seq)) { + log_debug("auth_validate: decreasing seq num, " + "interface %s", iface->name); + return (-1); + } + } + + /* XXX: maybe validate also the trailer header */ + if (a->auth_length != MD5_DIGEST_LENGTH + AUTH_TRLR_HDR_LEN) { + log_debug("auth_validate: invalid key length, " + "interface %s", iface->name); + return (-1); + } + + auth_data = *buf; + auth_data += ntohs(a->auth_offset); + + /* save the received digest and clear it in the packet */ + bcopy(auth_data, recv_digest, sizeof(recv_digest)); + bzero(auth_data, MD5_DIGEST_LENGTH); + + /* insert plaintext key */ + bzero(digest, MD5_DIGEST_LENGTH); + strncpy(digest, md->key, MD5_DIGEST_LENGTH); + + /* calculate MD5 digest */ + MD5Init(&hash); + MD5Update(&hash, b, ntohs(a->auth_offset) + RIP_HDR_LEN); + MD5Update(&hash, digest, MD5_DIGEST_LENGTH); + MD5Final(digest, &hash); + + if (bcmp(recv_digest, digest, sizeof(digest))) { + log_debug("auth_validate: invalid MD5 digest, " + "interface %s", iface->name); + return (-1); + } + + *crypt_seq_num = ntohl(a->auth_seq); + + *len -= AUTH_TRLR_HDR_LEN + MD5_DIGEST_LENGTH; + + break; + default: + log_debug("auth_validate: unknown auth type, interface %s", + iface->name); + return (-1); + } + + *buf += RIP_ENTRY_LEN; + *len -= RIP_ENTRY_LEN; + + return (0); +} + +int +auth_gen(struct buf *buf, struct iface *iface) +{ + struct rip_auth auth_head; + struct md5_auth a; + + auth_head.auth_fixed = AUTH; + auth_head.auth_type = htons(iface->auth_type); + + buf_add(buf, &auth_head, sizeof(auth_head)); + + switch (iface->auth_type) { + case AUTH_SIMPLE: + return (buf_add(buf, &iface->auth_key, MAX_SIMPLE_AUTH_LEN)); + break; + case AUTH_CRYPT: + bzero(&a, sizeof(a)); + a.auth_keyid = iface->auth_keyid; + a.auth_seq = htonl(auth_get_seq_num()); + a.auth_length = MD5_DIGEST_LENGTH + AUTH_TRLR_HDR_LEN; + + return (buf_add(buf, &a, sizeof(a))); + break; + default: + /* NOTREACHED */ + break; + } + + return (0); +} + +int +auth_add_trailer(struct buf *buf, struct iface *iface) +{ + MD5_CTX hash; + u_int8_t digest[MD5_DIGEST_LENGTH]; + struct auth_md *md; + struct md5_auth *a; + int pos; + + pos = sizeof(struct rip_hdr) + sizeof(struct rip_auth); + + /* add offset to header */ + a = buf_seek(buf, pos, sizeof(*a)); + a->auth_offset = htons(buf->wpos); + + /* insert plaintext key */ + if ((md = md_list_find(&iface->auth_md_list, + iface->auth_keyid)) == NULL) { + log_debug("auth_validate: keyid %d not configured, " + "interface %s", iface->auth_keyid, iface->name); + return (-1); + } + + bzero(digest, MD5_DIGEST_LENGTH); + strncpy(digest, md->key, MD5_DIGEST_LENGTH); + + auth_trailer_header_gen(buf); + + /* calculate MD5 digest */ + MD5Init(&hash); + MD5Update(&hash, buf->buf, buf->wpos); + MD5Update(&hash, digest, MD5_DIGEST_LENGTH); + MD5Final(digest, &hash); + + return (buf_add(buf, digest, MD5_DIGEST_LENGTH)); +} + +/* md list */ +void +md_list_add(struct auth_md_head *head, u_int8_t keyid, char *key) +{ + struct auth_md *md; + + if ((md = md_list_find(head, keyid)) != NULL) { + /* update key */ + strncpy(md->key, key, sizeof(md->key)); + return; + } + + if ((md = calloc(1, sizeof(struct auth_md))) == NULL) + fatalx("md_list_add"); + + md->keyid = keyid; + strncpy(md->key, key, sizeof(md->key)); + TAILQ_INSERT_TAIL(head, md, entry); +} + +void +md_list_copy(struct auth_md_head *to, struct auth_md_head *from) +{ + struct auth_md *m, *md; + + TAILQ_INIT(to); + + TAILQ_FOREACH(m, from, entry) { + if ((md = calloc(1, sizeof(struct auth_md))) == NULL) + fatalx("md_list_add"); + + md->keyid = m->keyid; + strncpy(md->key, m->key, sizeof(md->key)); + TAILQ_INSERT_TAIL(to, md, entry); + } +} + +void +md_list_clr(struct auth_md_head *head) +{ + struct auth_md *m; + + while ((m = TAILQ_FIRST(head)) != NULL) { + TAILQ_REMOVE(head, m, entry); + free(m); + } +} + +struct auth_md * +md_list_find(struct auth_md_head *head, u_int8_t keyid) +{ + struct auth_md *m; + + TAILQ_FOREACH(m, head, entry) + if (m->keyid == keyid) + return (m); + + return (NULL); +} diff --git a/usr.sbin/ripd/buffer.c b/usr.sbin/ripd/buffer.c new file mode 100644 index 00000000000..645f8588ff3 --- /dev/null +++ b/usr.sbin/ripd/buffer.c @@ -0,0 +1,218 @@ +/* $OpenBSD: buffer.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/uio.h> + +#include <errno.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "ripd.h" + +int buf_realloc(struct buf *, size_t); +void buf_enqueue(struct msgbuf *, struct buf *); +void buf_dequeue(struct msgbuf *, struct buf *); + +struct buf * +buf_open(size_t len) +{ + struct buf *buf; + + if ((buf = calloc(1, sizeof(struct buf))) == NULL) + return (NULL); + if ((buf->buf = malloc(len)) == NULL) { + free(buf); + return (NULL); + } + buf->size = buf->max = len; + + return (buf); +} + +struct buf * +buf_dynamic(size_t len, size_t max) +{ + struct buf *buf; + + if (max < len) + return (NULL); + + if ((buf = buf_open(len)) == NULL) + return (NULL); + + if (max > 0) + buf->max = max; + + return (buf); +} + +int +buf_realloc(struct buf *buf, size_t len) +{ + u_char *b; + + /* on static buffers max is eq size and so the following fails */ + if (buf->wpos + len > buf->max) { + errno = ENOMEM; + return (-1); + } + + b = realloc(buf->buf, buf->wpos + len); + if (b == NULL) + return (-1); + buf->buf = b; + buf->size = buf->wpos + len; + + return (0); +} + +int +buf_add(struct buf *buf, void *data, size_t len) +{ + if (buf->wpos + len > buf->size) + if (buf_realloc(buf, len) == -1) + return (-1); + + memcpy(buf->buf + buf->wpos, data, len); + buf->wpos += len; + return (0); +} + +void * +buf_reserve(struct buf *buf, size_t len) +{ + void *b; + + if (buf->wpos + len > buf->size) + if (buf_realloc(buf, len) == -1) + return (NULL); + + b = buf->buf + buf->wpos; + buf->wpos += len; + return (b); +} + +void * +buf_seek(struct buf *buf, size_t pos, size_t len) +{ + /* only allowed to seek in already written parts */ + if (pos + len > buf->wpos) + return (NULL); + + return (buf->buf + pos); +} + +int +buf_close(struct msgbuf *msgbuf, struct buf *buf) +{ + buf_enqueue(msgbuf, buf); + return (1); +} + +void +buf_free(struct buf *buf) +{ + free(buf->buf); + free(buf); +} + +void +msgbuf_init(struct msgbuf *msgbuf) +{ + msgbuf->queued = 0; + msgbuf->fd = -1; + TAILQ_INIT(&msgbuf->bufs); +} + +void +msgbuf_clear(struct msgbuf *msgbuf) +{ + struct buf *buf; + + while ((buf = TAILQ_FIRST(&msgbuf->bufs)) != NULL) + buf_dequeue(msgbuf, buf); +} + +int +msgbuf_write(struct msgbuf *msgbuf) +{ + struct iovec iov[IOV_MAX]; + struct buf *buf, *next; + int i = 0; + ssize_t n; + struct msghdr msg; + + bzero(&iov, sizeof(iov)); + bzero(&msg, sizeof(msg)); + TAILQ_FOREACH(buf, &msgbuf->bufs, entry) { + if (i >= IOV_MAX) + break; + iov[i].iov_base = buf->buf + buf->rpos; + iov[i].iov_len = buf->size - buf->rpos; + i++; + } + + msg.msg_iov = iov; + msg.msg_iovlen = i; + + if ((n = sendmsg(msgbuf->fd, &msg, 0)) == -1) { + if (errno == EAGAIN || errno == ENOBUFS || + errno == EINTR) /* try later */ + return (0); + else + return (-1); + } + + if (n == 0) { /* connection closed */ + errno = 0; + return (-2); + } + + for (buf = TAILQ_FIRST(&msgbuf->bufs); buf != NULL && n > 0; + buf = next) { + next = TAILQ_NEXT(buf, entry); + if (buf->rpos + n >= buf->size) { + n -= buf->size - buf->rpos; + buf_dequeue(msgbuf, buf); + } else { + buf->rpos += n; + n = 0; + } + } + + return (0); +} + +void +buf_enqueue(struct msgbuf *msgbuf, struct buf *buf) +{ + TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry); + msgbuf->queued++; +} + +void +buf_dequeue(struct msgbuf *msgbuf, struct buf *buf) +{ + TAILQ_REMOVE(&msgbuf->bufs, buf, entry); + msgbuf->queued--; + buf_free(buf); +} diff --git a/usr.sbin/ripd/control.c b/usr.sbin/ripd/control.c new file mode 100644 index 00000000000..77b3101cf41 --- /dev/null +++ b/usr.sbin/ripd/control.c @@ -0,0 +1,300 @@ +/* $OpenBSD: control.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <errno.h> +#include <fcntl.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "ripd.h" +#include "rip.h" +#include "ripe.h" +#include "log.h" +#include "control.h" + +#define CONTROL_BACKLOG 5 + +int control_imsg_relay(struct imsg *imsg); + +struct ctl_conn *control_connbyfd(int); +struct ctl_conn *control_connbypid(pid_t); +void control_close(int); + +int +control_init(void) +{ + struct sockaddr_un sun; + int fd; + mode_t old_umask; + + if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { + log_warn("control_init: socket"); + return (-1); + } + + bzero(&sun, sizeof(sun)); + sun.sun_family = AF_UNIX; + strlcpy(sun.sun_path, RIPD_SOCKET, sizeof(sun.sun_path)); + + if (unlink(RIPD_SOCKET) == -1) + if (errno != ENOENT) { + log_warn("control_init: unlink %s", RIPD_SOCKET); + close(fd); + return (-1); + } + + old_umask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH); + if (bind(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1) { + log_warn("control_init: bind: %s", RIPD_SOCKET); + close(fd); + umask(old_umask); + return (-1); + } + umask(old_umask); + + if (chmod(RIPD_SOCKET, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP) == -1) { + log_warn("control_init: chmod"); + close(fd); + (void)unlink(RIPD_SOCKET); + return (-1); + } + + session_socket_blockmode(fd, BM_NONBLOCK); + control_state.fd = fd; + + return (0); +} + +int +control_listen(void) +{ + + if (listen(control_state.fd, CONTROL_BACKLOG) == -1) { + log_warn("control_listen: listen"); + return (-1); + } + + event_set(&control_state.ev, control_state.fd, EV_READ | EV_PERSIST, + control_accept, NULL); + event_add(&control_state.ev, NULL); + + return (0); +} + +void +control_cleanup(void) +{ + unlink(RIPD_SOCKET); +} + +/* ARGSUSED */ +void +control_accept(int listenfd, short event, void *bula) +{ + int connfd; + socklen_t len; + struct sockaddr_un sun; + struct ctl_conn *c; + + len = sizeof(sun); + if ((connfd = accept(listenfd, + (struct sockaddr *)&sun, &len)) == -1) { + if (errno != EWOULDBLOCK && errno != EINTR) + log_warn("control_accept"); + return; + } + + session_socket_blockmode(connfd, BM_NONBLOCK); + + if ((c = malloc(sizeof(struct ctl_conn))) == NULL) { + log_warn("control_accept"); + return; + } + + imsg_init(&c->ibuf, connfd, control_dispatch_imsg); + c->ibuf.events = EV_READ; + event_set(&c->ibuf.ev, c->ibuf.fd, c->ibuf.events, + c->ibuf.handler, &c->ibuf); + event_add(&c->ibuf.ev, NULL); + + TAILQ_INSERT_TAIL(&ctl_conns, c, entry); +} + +struct ctl_conn * +control_connbyfd(int fd) +{ + struct ctl_conn *c; + + for (c = TAILQ_FIRST(&ctl_conns); c != NULL && c->ibuf.fd != fd; + c = TAILQ_NEXT(c, entry)) + ; /* nothing */ + + return (c); +} + +struct ctl_conn * +control_connbypid(pid_t pid) +{ + struct ctl_conn *c; + + for (c = TAILQ_FIRST(&ctl_conns); c != NULL && c->ibuf.pid != pid; + c = TAILQ_NEXT(c, entry)) + ; /* nothing */ + + return (c); +} + +void +control_close(int fd) +{ + struct ctl_conn *c; + + if ((c = control_connbyfd(fd)) == NULL) + log_warn("control_close: fd %d: not found", fd); + + msgbuf_clear(&c->ibuf.w); + TAILQ_REMOVE(&ctl_conns, c, entry); + + event_del(&c->ibuf.ev); + close(c->ibuf.fd); + free(c); +} + +/* ARGSUSED */ +void +control_dispatch_imsg(int fd, short event, void *bula) +{ + struct ctl_conn *c; + struct imsg imsg; + int n; + unsigned int ifidx; + + if ((c = control_connbyfd(fd)) == NULL) { + log_warn("control_dispatch_imsg: fd %d: not found", fd); + return; + } + + switch (event) { + case EV_READ: + if ((n = imsg_read(&c->ibuf)) <= 0) { + control_close(fd); + return; + } + break; + case EV_WRITE: + if (msgbuf_write(&c->ibuf.w) < 0) { + control_close(fd); + return; + } + imsg_event_add(&c->ibuf); + return; + default: + fatalx("unknown event"); + } + + for (;;) { + if ((n = imsg_get(&c->ibuf, &imsg)) == -1) { + control_close(fd); + return; + } + + if (n == 0) + break; + + switch (imsg.hdr.type) { + case IMSG_CTL_SHOW_INTERFACE: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(ifidx)) + return; + + memcpy(&ifidx, imsg.data, sizeof(ifidx)); + ripe_iface_ctl(c, ifidx); + imsg_compose(&c->ibuf, IMSG_CTL_END, 0, 0, NULL, 0); + + break; + case IMSG_CTL_SHOW_RIB: + c->ibuf.pid = imsg.hdr.pid; + ripe_imsg_compose_rde(imsg.hdr.type, 0, + imsg.hdr.pid, imsg.data, imsg.hdr.len - + IMSG_HEADER_SIZE); + break; + case IMSG_CTL_SHOW_NBR: + ripe_nbr_ctl(c); + break; + case IMSG_CTL_KROUTE_ADDR: + case IMSG_CTL_KROUTE: + c->ibuf.pid = imsg.hdr.pid; + ripe_imsg_compose_parent(imsg.hdr.type, + imsg.hdr.pid, imsg.data, + imsg.hdr.len - IMSG_HEADER_SIZE); + break; + case IMSG_CTL_IFINFO: + c->ibuf.pid = imsg.hdr.pid; + ripe_imsg_compose_parent(imsg.hdr.type, + imsg.hdr.pid, imsg.data, + imsg.hdr.len - IMSG_HEADER_SIZE); + break; + case IMSG_CTL_FIB_COUPLE: + case IMSG_CTL_FIB_DECOUPLE: + case IMSG_CTL_RELOAD: + c->ibuf.pid = imsg.hdr.pid; + ripe_imsg_compose_parent(imsg.hdr.type, 0, NULL, 0); + break; + default: + log_debug("control_dispatch_imsg: " + "error handling imsg %d", imsg.hdr.type); + break; + } + imsg_free(&imsg); + } + + imsg_event_add(&c->ibuf); +} + +int +control_imsg_relay(struct imsg *imsg) +{ + struct ctl_conn *c; + + if ((c = control_connbypid(imsg->hdr.pid)) == NULL) + return (0); + + return (imsg_compose(&c->ibuf, imsg->hdr.type, 0, imsg->hdr.pid, + imsg->data, imsg->hdr.len - IMSG_HEADER_SIZE)); +} + +void +session_socket_blockmode(int fd, enum blockmodes bm) +{ + int flags; + + if ((flags = fcntl(fd, F_GETFL, 0)) == -1) + fatal("fnctl F_GETFL"); + + if (bm == BM_NONBLOCK) + flags |= O_NONBLOCK; + else + flags &= ~O_NONBLOCK; + + if ((flags = fcntl(fd, F_SETFL, flags)) == -1) + fatal("fnctl F_SETFL"); +} diff --git a/usr.sbin/ripd/control.h b/usr.sbin/ripd/control.h new file mode 100644 index 00000000000..6d372673006 --- /dev/null +++ b/usr.sbin/ripd/control.h @@ -0,0 +1,50 @@ +/* $OpenBSD: control.h,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _CONTROL_H_ +#define _CONTROL_H_ + +#include <sys/queue.h> +#include <sys/time.h> +#include <event.h> + +struct { + struct event ev; + int fd; +} control_state; + +enum blockmodes { + BM_NORMAL, + BM_NONBLOCK +}; + +struct ctl_conn { + TAILQ_ENTRY(ctl_conn) entry; + struct imsgbuf ibuf; +}; + +int control_init(void); +int control_listen(void); +void control_accept(int, short, void *); +void control_dispatch_imsg(int, short, void *); +int control_imsg_relay(struct imsg *); +void control_cleanup(void); + +void session_socket_blockmode(int, enum blockmodes); + +#endif /* _CONTROL_H_ */ diff --git a/usr.sbin/ripd/imsg.c b/usr.sbin/ripd/imsg.c new file mode 100644 index 00000000000..51157ee5ad4 --- /dev/null +++ b/usr.sbin/ripd/imsg.c @@ -0,0 +1,178 @@ +/* $OpenBSD: imsg.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/uio.h> + +#include <errno.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "ripd.h" +#include "log.h" + +void +imsg_init(struct imsgbuf *ibuf, int fd, void (*handler)(int, short, void *)) +{ + msgbuf_init(&ibuf->w); + bzero(&ibuf->r, sizeof(ibuf->r)); + ibuf->fd = fd; + ibuf->w.fd = fd; + ibuf->pid = getpid(); + ibuf->handler = handler; + TAILQ_INIT(&ibuf->fds); +} + +ssize_t +imsg_read(struct imsgbuf *ibuf) +{ + ssize_t n; + + if ((n = recv(ibuf->fd, ibuf->r.buf + ibuf->r.wpos, + sizeof(ibuf->r.buf) - ibuf->r.wpos, 0)) == -1) { + if (errno != EINTR && errno != EAGAIN) { + log_warn("imsg_read: pipe read error"); + return (-1); + } + return (0); + } + + ibuf->r.wpos += n; + + return (n); +} + +ssize_t +imsg_get(struct imsgbuf *ibuf, struct imsg *imsg) +{ + size_t av, left, datalen; + + av = ibuf->r.wpos; + + if (IMSG_HEADER_SIZE > av) + return (0); + + memcpy(&imsg->hdr, ibuf->r.buf, sizeof(imsg->hdr)); + if (imsg->hdr.len < IMSG_HEADER_SIZE || + imsg->hdr.len > MAX_IMSGSIZE) { + log_warnx("imsg_get: imsg hdr len %u out of bounds, type=%u", + imsg->hdr.len, imsg->hdr.type); + return (-1); + } + if (imsg->hdr.len > av) + return (0); + datalen = imsg->hdr.len - IMSG_HEADER_SIZE; + ibuf->r.rptr = ibuf->r.buf + IMSG_HEADER_SIZE; + if ((imsg->data = malloc(datalen)) == NULL) { + log_warn("imsg_get"); + return (-1); + } + memcpy(imsg->data, ibuf->r.rptr, datalen); + + if (imsg->hdr.len < av) { + left = av - imsg->hdr.len; + memmove(&ibuf->r.buf, ibuf->r.buf + imsg->hdr.len, left); + ibuf->r.wpos = left; + } else + ibuf->r.wpos = 0; + + return (datalen + IMSG_HEADER_SIZE); +} + +int +imsg_compose(struct imsgbuf *ibuf, enum imsg_type type, u_int32_t peerid, + pid_t pid, void *data, u_int16_t datalen) +{ + struct buf *wbuf; + int n; + + if ((wbuf = imsg_create(ibuf, type, peerid, pid, datalen)) == NULL) + return (-1); + + if (imsg_add(wbuf, data, datalen) == -1) + return (-1); + + if ((n = imsg_close(ibuf, wbuf)) < 0) + return (-1); + + return (n); +} + +/* ARGSUSED */ +struct buf * +imsg_create(struct imsgbuf *ibuf, enum imsg_type type, u_int32_t peerid, + pid_t pid, u_int16_t datalen) +{ + struct buf *wbuf; + struct imsg_hdr hdr; + + if (datalen > MAX_IMSGSIZE - IMSG_HEADER_SIZE) { + log_warnx("imsg_create: len %u > MAX_IMSGSIZE; " + "type %u peerid %lu", datalen + IMSG_HEADER_SIZE, + type, peerid); + return (NULL); + } + + hdr.len = (u_int16_t)(datalen + IMSG_HEADER_SIZE); + hdr.type = type; + hdr.peerid = peerid; + if ((hdr.pid = pid) == 0) + hdr.pid = ibuf->pid; + if ((wbuf = buf_open(hdr.len)) == NULL) { + log_warn("imsg_create: buf_open"); + return (NULL); + } + if (imsg_add(wbuf, &hdr, sizeof(hdr)) == -1) + return (NULL); + + return (wbuf); +} + +int +imsg_add(struct buf *msg, void *data, u_int16_t datalen) +{ + if (datalen) + if (buf_add(msg, data, datalen) == -1) { + log_warnx("imsg_add: buf_add error"); + buf_free(msg); + return (-1); + } + return (datalen); +} + +int +imsg_close(struct imsgbuf *ibuf, struct buf *msg) +{ + int n; + + if ((n = buf_close(&ibuf->w, msg)) < 0) { + log_warnx("imsg_close: buf_close error"); + buf_free(msg); + return (-1); + } + imsg_event_add(ibuf); + + return (n); +} + +void +imsg_free(struct imsg *imsg) +{ + free(imsg->data); +} diff --git a/usr.sbin/ripd/interface.c b/usr.sbin/ripd/interface.c new file mode 100644 index 00000000000..be9917361ad --- /dev/null +++ b/usr.sbin/ripd/interface.c @@ -0,0 +1,482 @@ +/* $OpenBSD: interface.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org> + * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <net/if.h> +#include <net/if_types.h> +#include <ctype.h> +#include <err.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <event.h> + +#include "ripd.h" +#include "log.h" +#include "rip.h" +#include "rde.h" +#include "ripe.h" + +extern struct ripd_conf *conf; + +int if_act_start(struct iface *); +int if_act_reset(struct iface *); +void if_keepalive_timer(int, short, void *); + +struct { + int state; + enum iface_event event; + enum iface_action action; + int new_state; +} iface_fsm[] = { + /* current state event that happened action to take resulting state */ + {IF_STA_DOWN, IF_EVT_UP, IF_ACT_STRT, 0}, + {IF_STA_ANY, IF_EVT_DOWN, IF_ACT_RST, IF_STA_DOWN}, + {-1, IF_EVT_NOTHING, IF_ACT_NOTHING, 0}, +}; + +const char * const if_action_names[] = { + "NOTHING", + "START", + "RESET" +}; + +static const char * const if_event_names[] = { + "NOTHING", + "UP", + "DOWN", +}; + +void +if_init(struct ripd_conf *xconf, struct iface *iface) +{ + /* XXX as in ospfd I would like to kill that. This is a design error */ + iface->fd = xconf->rip_socket; +} + +int +if_fsm(struct iface *iface, enum iface_event event) +{ + int old_state; + int new_state = 0; + int i, ret = 0; + + old_state = iface->state; + + for (i = 0; iface_fsm[i].state != -1; i++) + if ((iface_fsm[i].state & old_state) && + (iface_fsm[i].event == event)) { + new_state = iface_fsm[i].new_state; + break; + } + + if (iface_fsm[i].state == -1) { + /* event outside of the defined fsm, ignore it. */ + log_debug("if_fsm: interface %s, " + "event '%s' not expected in state '%s'", iface->name, + if_event_name(event), if_state_name(old_state)); + return (0); + } + + switch (iface_fsm[i].action) { + case IF_ACT_STRT: + ret = if_act_start(iface); + break; + case IF_ACT_RST: + ret = if_act_reset(iface); + break; + case IF_ACT_NOTHING: + /* do nothing */ + break; + } + + if (ret) { + log_debug("if_fsm: error changing state for interface %s, " + "event '%s', state '%s'", iface->name, if_event_name(event), + if_state_name(old_state)); + return (0); + } + + if (new_state != 0) + iface->state = new_state; + + log_debug("if_fsm: event '%s' resulted in action '%s' and changing " + "state for interface %s from '%s' to '%s'", + if_event_name(event), if_action_name(iface_fsm[i].action), + iface->name, if_state_name(old_state), if_state_name(iface->state)); + + return (ret); +} + +struct iface * +if_find_index(u_short ifindex) +{ + struct iface *iface; + + LIST_FOREACH(iface, &conf->iface_list, entry) { + if (iface->ifindex == ifindex) + return (iface); + } + + return (NULL); +} + + +/* actions */ +int +if_act_start(struct iface *iface) +{ + struct in_addr addr; + struct timeval now; + + if (iface->passive) { + log_debug("if_act_start: cannot start passive interface %s", + iface->name); + return (0); + } + + if (!((iface->flags & IFF_UP) && + (iface->linkstate == LINK_STATE_UP || + (iface->linkstate == LINK_STATE_UNKNOWN && + iface->media_type != IFT_CARP)))) { + log_debug("if_act_start: interface %s link down", + iface->name); + return (0); + } + + gettimeofday(&now, NULL); + iface->uptime = now.tv_sec; + + switch (iface->type) { + case IF_TYPE_POINTOPOINT: + case IF_TYPE_BROADCAST: + inet_aton(ALL_RIP_ROUTERS, &addr); + if (if_join_group(iface, &addr)) { + log_warn("if_act_start: error joining group %s, " + "interface %s", inet_ntoa(addr), iface->name); + return (-1); + } + + iface->state = IF_STA_ACTIVE; + break; + default: + fatalx("if_act_start: unknown interface type"); + } + + return (0); +} + +int +if_act_reset(struct iface *iface) +{ + struct nbr *nbr = NULL; + struct in_addr addr; + + if (iface->passive) + return (0); + + switch (iface->type) { + case IF_TYPE_POINTOPOINT: + case IF_TYPE_BROADCAST: + inet_aton(ALL_RIP_ROUTERS, &addr); + if (if_leave_group(iface, &addr)) { + log_warn("if_act_reset: error leaving group %s, " + "interface %s", inet_ntoa(addr), iface->name); + } + break; + default: + fatalx("if_act_reset: unknown interface type"); + } + + LIST_FOREACH(nbr, &iface->nbr_list, entry) { + if (nbr_fsm(nbr, NBR_EVT_KILL_NBR)) { + log_debug("if_act_reset: error killing neighbor %s", + inet_ntoa(nbr->id)); + } + } + + return (0); +} + +const char * +if_event_name(int event) +{ + return (if_event_names[event]); +} + +const char * +if_action_name(int action) +{ + return (if_action_names[action]); +} + +/* misc */ +int +if_set_mcast_ttl(int fd, u_int8_t ttl) +{ + if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, + (char *)&ttl, sizeof(ttl)) < 0) { + log_warn("if_set_mcast_ttl: error setting " + "IP_MULTICAST_TTL to %d", ttl); + return (-1); + } + + return (0); +} + +int +if_set_opt(int fd) +{ + int yes = 1; + + if (setsockopt(fd, IPPROTO_IP, IP_RECVIF, &yes, + sizeof(int)) < 0) { + log_warn("if_set_opt: error setting IP_RECVIF"); + return (-1); + } + + return (0); +} + +int +if_set_tos(int fd, int tos) +{ + if (setsockopt(fd, IPPROTO_IP, IP_TOS, + (int *)&tos, sizeof(tos)) < 0) { + log_warn("if_set_tos: error setting IP_TOS to 0x%x", tos); + return (-1); + } + + return (0); +} + +int +if_set_mcast(struct iface *iface) +{ + switch (iface->type) { + case IF_TYPE_POINTOPOINT: + case IF_TYPE_BROADCAST: + if (setsockopt(iface->fd, IPPROTO_IP, IP_MULTICAST_IF, + &iface->addr.s_addr, sizeof(iface->addr.s_addr)) < 0) { + log_debug("if_set_mcast: error setting " + "IP_MULTICAST_IF, interface %s", iface->name); + return (-1); + } + break; + default: + fatalx("if_set_mcast: unknown interface type"); + } + + return (0); +} + +int +if_set_mcast_loop(int fd) +{ + u_int8_t loop = 0; + + if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, + (char *)&loop, sizeof(loop)) < 0) { + log_warn("if_set_mcast_loop: error setting IP_MULTICAST_LOOP"); + return (-1); + } + + return (0); +} + +void +if_set_recvbuf(int fd) +{ + int bsize; + + bsize = 65535; + while (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bsize, + sizeof(bsize)) == -1) + bsize /= 2; +} + +int +if_join_group(struct iface *iface, struct in_addr *addr) +{ + struct ip_mreq mreq; + + switch (iface->type) { + case IF_TYPE_POINTOPOINT: + case IF_TYPE_BROADCAST: + mreq.imr_multiaddr.s_addr = addr->s_addr; + mreq.imr_interface.s_addr = iface->addr.s_addr; + + if (setsockopt(iface->fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, + (void *)&mreq, sizeof(mreq)) < 0) + return (-1); + break; + default: + fatalx("if_join_group: unknown interface type"); + } + + return (0); +} + +int +if_leave_group(struct iface *iface, struct in_addr *addr) +{ + struct ip_mreq mreq; + + switch (iface->type) { + case IF_TYPE_POINTOPOINT: + case IF_TYPE_BROADCAST: + mreq.imr_multiaddr.s_addr = addr->s_addr; + mreq.imr_interface.s_addr = iface->addr.s_addr; + + if (setsockopt(iface->fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, + (void *)&mreq, sizeof(mreq)) < 0) + return (-1); + break; + default: + fatalx("if_leave_group: unknown interface type"); + } + + return (0); +} + +struct iface * +if_new(struct kif *kif) +{ + struct sockaddr_in *sain; + struct iface *iface; + struct ifreq *ifr; + int s; + + if ((iface = calloc(1, sizeof(*iface))) == NULL) + err(1, "if_new: calloc"); + + iface->state = IF_STA_DOWN; + + LIST_INIT(&iface->nbr_list); + TAILQ_INIT(&iface->rp_list); + TAILQ_INIT(&iface->rq_list); + + strlcpy(iface->name, kif->ifname, sizeof(iface->name)); + + if ((ifr = calloc(1, sizeof(*ifr))) == NULL) + err(1, "if_new: calloc"); + + /* set up ifreq */ + strlcpy(ifr->ifr_name, kif->ifname, sizeof(ifr->ifr_name)); + if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) + err(1, "if_new: socket"); + + /* get type */ + if (kif->flags & IFF_POINTOPOINT) + iface->type = IF_TYPE_POINTOPOINT; + if (kif->flags & IFF_BROADCAST && + kif->flags & IFF_MULTICAST) + iface->type = IF_TYPE_BROADCAST; + if (kif->flags & IFF_LOOPBACK) { + iface->type = IF_TYPE_POINTOPOINT; + /* XXX protect loopback from sending packets over lo? */ + } + + /* get mtu, index and flags */ + iface->mtu = kif->mtu; + iface->ifindex = kif->ifindex; + iface->flags = kif->flags; + iface->linkstate = kif->link_state; + iface->media_type = kif->media_type; + + /* get address */ + if (ioctl(s, SIOCGIFADDR, ifr) < 0) + err(1, "if_new: cannot get address"); + sain = (struct sockaddr_in *)&ifr->ifr_addr; + iface->addr = sain->sin_addr; + + /* get mask */ + if (ioctl(s, SIOCGIFNETMASK, ifr) < 0) + err(1, "if_new: cannot get mask"); + sain = (struct sockaddr_in *)&ifr->ifr_addr; + iface->mask = sain->sin_addr; + + /* get p2p dst address */ + if (kif->flags & IFF_POINTOPOINT) { + if (ioctl(s, SIOCGIFDSTADDR, ifr) < 0) + err(1, "if_new: cannot get dst addr"); + sain = (struct sockaddr_in *)&ifr->ifr_addr; + iface->dst = sain->sin_addr; + } + + free(ifr); + close(s); + + return (iface); +} + +void +if_del(struct iface *iface) +{ + struct nbr *nbr; + + log_debug("if_del: interface %s", iface->name); + + /* clear lists etc */ + while ((nbr = LIST_FIRST(&iface->nbr_list)) != NULL) + nbr_act_del(nbr); + + /* XXX rq_list, rp_list */ + + free(iface); +} + +struct ctl_iface * +if_to_ctl(struct iface *iface) +{ + static struct ctl_iface ictl; + struct timeval now; + + memcpy(ictl.name, iface->name, sizeof(ictl.name)); + memcpy(&ictl.addr, &iface->addr, sizeof(ictl.addr)); + memcpy(&ictl.mask, &iface->mask, sizeof(ictl.mask)); + + ictl.ifindex = iface->ifindex; + ictl.state = iface->state; + ictl.mtu = iface->mtu; + + ictl.baudrate = iface->baudrate; + ictl.flags = iface->flags; + ictl.metric = iface->cost; + ictl.type = iface->type; + ictl.linkstate = iface->linkstate; + ictl.passive = iface->passive; + ictl.mediatype = iface->media_type; + + gettimeofday(&now, NULL); + + if (iface->state != IF_STA_DOWN) { + ictl.uptime = now.tv_sec - iface->uptime; + } else + ictl.uptime = 0; + + return (&ictl); +} diff --git a/usr.sbin/ripd/kroute.c b/usr.sbin/ripd/kroute.c new file mode 100644 index 00000000000..39a18ab353b --- /dev/null +++ b/usr.sbin/ripd/kroute.c @@ -0,0 +1,1126 @@ +/* $OpenBSD: kroute.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2004 Esben Norby <norby@openbsd.org> + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/sysctl.h> +#include <sys/tree.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <net/if.h> +#include <net/if_dl.h> +#include <net/if_types.h> +#include <net/route.h> +#include <err.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "ripd.h" +#include "log.h" + +struct { + u_int32_t rtseq; + pid_t pid; + int fib_sync; + int fd; + struct event ev; +} kr_state; + +struct kroute_node { + RB_ENTRY(kroute_node) entry; + struct kroute r; +}; + +struct kif_node { + RB_ENTRY(kif_node) entry; + struct kif k; +}; + +void kr_redistribute(int, struct kroute *); +int kroute_compare(struct kroute_node *, struct kroute_node *); +int kif_compare(struct kif_node *, struct kif_node *); + +struct kroute_node *kroute_find(in_addr_t, in_addr_t); +int kroute_insert(struct kroute_node *); +int kroute_remove(struct kroute_node *); +void kroute_clear(void); + +struct kif_node *kif_find(int); +int kif_insert(struct kif_node *); +int kif_remove(struct kif_node *); +void kif_clear(void); +int kif_validate(int); + +struct kroute_node *kroute_match(in_addr_t); + +int protect_lo(void); +u_int8_t prefixlen_classful(in_addr_t); +void get_rtaddrs(int, struct sockaddr *, struct sockaddr **); +void if_change(u_short, int, struct if_data *); +void if_announce(void *); + +int send_rtmsg(int, int, struct kroute *); +int dispatch_rtmsg(void); +int fetchtable(void); +int fetchifs(int); + +RB_HEAD(kroute_tree, kroute_node) krt; +RB_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare) +RB_GENERATE(kroute_tree, kroute_node, entry, kroute_compare) + +RB_HEAD(kif_tree, kif_node) kit; +RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) +RB_GENERATE(kif_tree, kif_node, entry, kif_compare) + +int +kif_init(void) +{ + RB_INIT(&kit); + + if (fetchifs(0) == -1) + return (-1); + + return (0); +} + +int +kr_init(int fs) +{ + int opt = 0, rcvbuf, default_rcvbuf; + socklen_t optlen; + + kr_state.fib_sync = fs; + + if ((kr_state.fd = socket(AF_ROUTE, SOCK_RAW, 0)) == -1) { + log_warn("kr_init: socket"); + return (-1); + } + + /* not interested in my own messages */ + if (setsockopt(kr_state.fd, SOL_SOCKET, SO_USELOOPBACK, + &opt, sizeof(opt)) == -1) + log_warn("kr_init: setsockopt"); /* not fatal */ + + /* grow receive buffer, don't wanna miss messages */ + optlen = sizeof(default_rcvbuf); + if (getsockopt(kr_state.fd, SOL_SOCKET, SO_RCVBUF, + &default_rcvbuf, &optlen) == -1) + log_warn("kr_init getsockopt SOL_SOCKET SO_RCVBUF"); + else + for (rcvbuf = MAX_RTSOCK_BUF; + rcvbuf > default_rcvbuf && + setsockopt(kr_state.fd, SOL_SOCKET, SO_RCVBUF, + &rcvbuf, sizeof(rcvbuf)) == -1 && errno == ENOBUFS; + rcvbuf /= 2) + ; /* nothing */ + + kr_state.pid = getpid(); + kr_state.rtseq = 1; + + RB_INIT(&krt); + + if (fetchtable() == -1) + return (-1); + + if (protect_lo() == -1) + return (-1); + + event_set(&kr_state.ev, kr_state.fd, EV_READ | EV_PERSIST, + kr_dispatch_msg, NULL); + event_add(&kr_state.ev, NULL); + + return (0); +} + +int +kr_change(struct kroute *kroute) +{ + struct kroute_node *kr; + int action = RTM_ADD; + + if ((kr = kroute_find(kroute->prefix.s_addr, kroute->netmask.s_addr)) != + NULL) { + if (!(kr->r.flags & F_KERNEL)) + action = RTM_CHANGE; + else { /* a non-rip route already exists. not a problem */ + if (!(kr->r.flags & (F_BGPD_INSERTED| + F_OSPFD_INSERTED))) { + kr->r.flags |= F_RIPD_INSERTED; + return (0); + } + /* + * rip route has higher pref + * - reset flags to the rip ones + * - use RTM_CHANGE + * - zero out ifindex (this is no longer relevant) + */ + action = RTM_CHANGE; + kr->r.flags = kroute->flags | F_RIPD_INSERTED; + kr->r.ifindex = 0; + } + } + + /* nexthop within 127/8 -> ignore silently */ + if ((kroute->nexthop.s_addr & htonl(IN_CLASSA_NET)) == + htonl(INADDR_LOOPBACK & IN_CLASSA_NET)) + return (0); + + if (send_rtmsg(kr_state.fd, action, kroute) == -1) + return (-1); + + if (action == RTM_ADD) { + if ((kr = calloc(1, sizeof(struct kroute_node))) == NULL) { + log_warn("kr_change"); + return (-1); + } + kr->r.prefix.s_addr = kroute->prefix.s_addr; + kr->r.netmask.s_addr = kroute->netmask.s_addr; + kr->r.nexthop.s_addr = kroute->nexthop.s_addr; + kr->r.flags = kroute->flags |= F_RIPD_INSERTED; + + if (kroute_insert(kr) == -1) + free(kr); + } else + kr->r.nexthop.s_addr = kroute->nexthop.s_addr; + + return (0); +} + +int +kr_delete(struct kroute *kroute) +{ + struct kroute_node *kr; + + if ((kr = kroute_find(kroute->prefix.s_addr, kroute->netmask.s_addr)) == + NULL) + return (0); + + if (!(kr->r.flags & F_RIPD_INSERTED)) + return (0); + + if (kr->r.flags & F_KERNEL) { + /* remove F_RIPD_INSERTED flag, route still exists in kernel */ + kr->r.flags &= ~F_RIPD_INSERTED; + return (0); + } + + if (send_rtmsg(kr_state.fd, RTM_DELETE, kroute) == -1) + return (-1); + + if (kroute_remove(kr) == -1) + return (-1); + + return (0); +} + +void +kr_shutdown(void) +{ + kr_fib_decouple(); + kroute_clear(); + kif_clear(); +} + +void +kr_fib_couple(void) +{ + struct kroute_node *kr; + + if (kr_state.fib_sync == 1) /* already coupled */ + return; + + kr_state.fib_sync = 1; + + RB_FOREACH(kr, kroute_tree, &krt) + if (!(kr->r.flags & F_KERNEL)) + send_rtmsg(kr_state.fd, RTM_ADD, &kr->r); + + log_info("kernel routing table coupled"); +} + +void +kr_fib_decouple(void) +{ + struct kroute_node *kr; + + if (kr_state.fib_sync == 0) /* already decoupled */ + return; + + RB_FOREACH(kr, kroute_tree, &krt) + if (!(kr->r.flags & F_KERNEL)) + send_rtmsg(kr_state.fd, RTM_DELETE, &kr->r); + + kr_state.fib_sync = 0; + + log_info("kernel routing table decoupled"); +} + +/* ARGSUSED */ +void +kr_dispatch_msg(int fd, short event, void *bula) +{ + dispatch_rtmsg(); +} + +void +kr_show_route(struct imsg *imsg) +{ + struct kroute_node *kr; + int flags; + struct in_addr addr; + + switch (imsg->hdr.type) { + case IMSG_CTL_KROUTE: + if (imsg->hdr.len != IMSG_HEADER_SIZE + sizeof(flags)) { + log_warnx("kr_show_route: wrong imsg len"); + return; + } + memcpy(&flags, imsg->data, sizeof(flags)); + RB_FOREACH(kr, kroute_tree, &krt) + if (!flags || kr->r.flags & flags) { + main_imsg_compose_ripe(IMSG_CTL_KROUTE, + imsg->hdr.pid, &kr->r, sizeof(kr->r)); + } + break; + case IMSG_CTL_KROUTE_ADDR: + if (imsg->hdr.len != IMSG_HEADER_SIZE + + sizeof(struct in_addr)) { + log_warnx("kr_show_route: wrong imsg len"); + return; + } + memcpy(&addr, imsg->data, sizeof(addr)); + kr = NULL; + kr = kroute_match(addr.s_addr); + if (kr != NULL) + main_imsg_compose_ripe(IMSG_CTL_KROUTE, imsg->hdr.pid, + &kr->r, sizeof(kr->r)); + break; + default: + log_debug("kr_show_route: error handling imsg"); + break; + } + + main_imsg_compose_ripe(IMSG_CTL_END, imsg->hdr.pid, NULL, 0); +} + +void +kr_ifinfo(char *ifname, pid_t pid) +{ + struct kif_node *kif; + + RB_FOREACH(kif, kif_tree, &kit) + if (ifname == NULL || !strcmp(ifname, kif->k.ifname)) { + main_imsg_compose_ripe(IMSG_CTL_IFINFO, + pid, &kif->k, sizeof(kif->k)); + } + + main_imsg_compose_ripe(IMSG_CTL_END, pid, NULL, 0); +} + +void +kr_redistribute(int type, struct kroute *kr) +{ + u_int32_t a; + + + if (type == IMSG_NETWORK_DEL) { +dont_redistribute: + /* was the route redistributed? */ + if (kr->flags & F_REDISTRIBUTED) { + /* remove redistributed flag */ + kr->flags &= ~F_REDISTRIBUTED; + main_imsg_compose_rde(type, 0, kr, + sizeof(struct kroute)); + } + return; + } + + /* interface is not up and running so don't announce */ + if (kr->flags & F_DOWN) + return; + + /* + * We consider the loopback net, multicast and experimental addresses + * as not redistributable. + */ + a = ntohl(kr->prefix.s_addr); + if (IN_MULTICAST(a) || IN_BADCLASS(a) || + (a >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) + return; + /* + * Consider networks with nexthop loopback as not redistributable. + */ + if (kr->nexthop.s_addr == htonl(INADDR_LOOPBACK)) + return; + + /* Should we redistrubute this route? */ + if (!rip_redistribute(kr)) + goto dont_redistribute; + + /* Does not matter if we resend the kr, the RDE will cope. */ + kr->flags |= F_REDISTRIBUTED; + main_imsg_compose_rde(type, 0, kr, sizeof(struct kroute)); +} + +/* rb-tree compare */ +int +kroute_compare(struct kroute_node *a, struct kroute_node *b) +{ + if (ntohl(a->r.prefix.s_addr) < ntohl(b->r.prefix.s_addr)) + return (-1); + if (ntohl(a->r.prefix.s_addr) > ntohl(b->r.prefix.s_addr)) + return (1); + if (ntohl(a->r.netmask.s_addr) < ntohl(b->r.netmask.s_addr)) + return (-1); + if (ntohl(a->r.netmask.s_addr) > ntohl(b->r.netmask.s_addr)) + return (1); + return (0); +} + +int +kif_compare(struct kif_node *a, struct kif_node *b) +{ + return (b->k.ifindex - a->k.ifindex); +} + +/* tree management */ +struct kroute_node * +kroute_find(in_addr_t prefix, in_addr_t netmask) +{ + struct kroute_node s; + + s.r.prefix.s_addr = prefix; + s.r.netmask.s_addr = netmask; + + return (RB_FIND(kroute_tree, &krt, &s)); +} + +int +kroute_insert(struct kroute_node *kr) +{ + if (RB_INSERT(kroute_tree, &krt, kr) != NULL) { + log_warnx("kroute_insert failed for %s/%u", + inet_ntoa(kr->r.prefix), + mask2prefixlen(kr->r.netmask.s_addr)); + free(kr); + return (-1); + } + + if (!(kr->r.flags & F_KERNEL)) { + /* don't validate or redistribute rip route */ + kr->r.flags &= ~F_DOWN; + return (0); + } + + if (kif_validate(kr->r.ifindex)) + kr->r.flags &= ~F_DOWN; + else + kr->r.flags |= F_DOWN; + + kr_redistribute(IMSG_NETWORK_ADD, &kr->r); + + return (0); +} + +int +kroute_remove(struct kroute_node *kr) +{ + if (RB_REMOVE(kroute_tree, &krt, kr) == NULL) { + log_warnx("kroute_remove failed for %s/%u", + inet_ntoa(kr->r.prefix), + mask2prefixlen(kr->r.netmask.s_addr)); + return (-1); + } + + kr_redistribute(IMSG_NETWORK_DEL, &kr->r); + + free(kr); + return (0); +} + +void +kroute_clear(void) +{ + struct kroute_node *kr; + + while ((kr = RB_MIN(kroute_tree, &krt)) != NULL) + kroute_remove(kr); +} + +struct kif_node * +kif_find(int ifindex) +{ + struct kif_node s; + + bzero(&s, sizeof(s)); + s.k.ifindex = ifindex; + + return (RB_FIND(kif_tree, &kit, &s)); +} + +struct kif * +kif_findname(char *ifname) +{ + struct kif_node *kif; + + RB_FOREACH(kif, kif_tree, &kit) + if (!strcmp(ifname, kif->k.ifname)) + return (&kif->k); + + return (NULL); +} + +int +kif_insert(struct kif_node *kif) +{ + if (RB_INSERT(kif_tree, &kit, kif) != NULL) { + log_warnx("RB_INSERT(kif_tree, &kit, kif)"); + free(kif); + return (-1); + } + + return (0); +} + +int +kif_remove(struct kif_node *kif) +{ + if (RB_REMOVE(kif_tree, &kit, kif) == NULL) { + log_warnx("RB_REMOVE(kif_tree, &kit, kif)"); + return (-1); + } + + free(kif); + return (0); +} + +void +kif_clear(void) +{ + struct kif_node *kif; + + while ((kif = RB_MIN(kif_tree, &kit)) != NULL) + kif_remove(kif); +} + +int +kif_validate(int ifindex) +{ + struct kif_node *kif; + + if ((kif = kif_find(ifindex)) == NULL) { + log_warnx("interface with index %u not found", ifindex); + return (1); + } + + return (kif->k.nh_reachable); +} + +struct kroute_node * +kroute_match(in_addr_t key) +{ + int i; + struct kroute_node *kr; + + /* we will never match the default route */ + for (i = 32; i > 0; i--) + if ((kr = kroute_find(key & prefixlen2mask(i), + prefixlen2mask(i))) != NULL) + return (kr); + + /* if we don't have a match yet, try to find a default route */ + if ((kr = kroute_find(0, 0)) != NULL) + return (kr); + + return (NULL); +} + +/* misc */ +int +protect_lo(void) +{ + struct kroute_node *kr; + + /* special protection for 127/8 */ + if ((kr = calloc(1, sizeof(struct kroute_node))) == NULL) { + log_warn("protect_lo"); + return (-1); + } + kr->r.prefix.s_addr = htonl(INADDR_LOOPBACK); + kr->r.netmask.s_addr = htonl(IN_CLASSA_NET); + kr->r.flags = F_KERNEL|F_CONNECTED; + + if (RB_INSERT(kroute_tree, &krt, kr) != NULL) + free(kr); /* kernel route already there, no problem */ + + return (0); +} + +u_int8_t +prefixlen_classful(in_addr_t ina) +{ + /* it hurt to write this. */ + + if (ina >= 0xf0000000U) /* class E */ + return (32); + else if (ina >= 0xe0000000U) /* class D */ + return (4); + else if (ina >= 0xc0000000U) /* class C */ + return (24); + else if (ina >= 0x80000000U) /* class B */ + return (16); + else /* class A */ + return (8); +} + +u_int8_t +mask2prefixlen(in_addr_t ina) +{ + if (ina == 0) + return (0); + else + return (33 - ffs(ntohl(ina))); +} + +in_addr_t +prefixlen2mask(u_int8_t prefixlen) +{ + if (prefixlen == 0) + return (0); + + return (htonl(0xffffffff << (32 - prefixlen))); +} + +#define ROUNDUP(a, size) \ + (((a) & ((size) - 1)) ? (1 + ((a) | ((size) - 1))) : (a)) + +void +get_rtaddrs(int addrs, struct sockaddr *sa, struct sockaddr **rti_info) +{ + int i; + + for (i = 0; i < RTAX_MAX; i++) { + if (addrs & (1 << i)) { + rti_info[i] = sa; + sa = (struct sockaddr *)((char *)(sa) + + ROUNDUP(sa->sa_len, sizeof(long))); + } else + rti_info[i] = NULL; + } +} + +void +if_change(u_short ifindex, int flags, struct if_data *ifd) +{ + struct kif_node *kif; + struct kroute_node *kr; + int type; + u_int8_t reachable; + + if ((kif = kif_find(ifindex)) == NULL) { + log_warnx("interface with index %u not found", ifindex); + return; + } + + kif->k.flags = flags; + kif->k.link_state = ifd->ifi_link_state; + kif->k.media_type = ifd->ifi_type; + kif->k.baudrate = ifd->ifi_baudrate; + + if ((reachable = (flags & IFF_UP) && + (ifd->ifi_link_state == LINK_STATE_UP || + (ifd->ifi_link_state == LINK_STATE_UNKNOWN && + ifd->ifi_type != IFT_CARP))) == kif->k.nh_reachable) + return; /* nothing changed wrt nexthop validity */ + + kif->k.nh_reachable = reachable; + type = reachable ? IMSG_NETWORK_ADD : IMSG_NETWORK_DEL; + + /* notify ripe about interface link state */ + main_imsg_compose_ripe(IMSG_IFINFO, 0, &kif->k, sizeof(kif->k)); + + /* update redistribute list */ + RB_FOREACH(kr, kroute_tree, &krt) + if (kr->r.ifindex == ifindex) { + if (reachable) + kr->r.flags &= ~F_DOWN; + else + kr->r.flags |= F_DOWN; + + kr_redistribute(type, &kr->r); + } +} + +void +if_announce(void *msg) +{ + struct if_announcemsghdr *ifan; + struct kif_node *kif; + + ifan = msg; + + switch (ifan->ifan_what) { + case IFAN_ARRIVAL: + if ((kif = calloc(1, sizeof(struct kif_node))) == NULL) { + log_warn("if_announce"); + return; + } + + kif->k.ifindex = ifan->ifan_index; + strlcpy(kif->k.ifname, ifan->ifan_name, sizeof(kif->k.ifname)); + kif_insert(kif); + break; + case IFAN_DEPARTURE: + kif = kif_find(ifan->ifan_index); + kif_remove(kif); + break; + } +} + +/* rtsock */ +int +send_rtmsg(int fd, int action, struct kroute *kroute) +{ + struct { + struct rt_msghdr hdr; + struct sockaddr_in prefix; + struct sockaddr_in nexthop; + struct sockaddr_in mask; + } r; + + if (kr_state.fib_sync == 0) + return (0); + + bzero(&r, sizeof(r)); + r.hdr.rtm_msglen = sizeof(r); + r.hdr.rtm_version = RTM_VERSION; + r.hdr.rtm_type = action; + r.hdr.rtm_flags = RTF_PROTO3; + if (action == RTM_CHANGE) /* force PROTO3 reset the other flags */ + r.hdr.rtm_fmask = + RTF_PROTO3|RTF_PROTO2|RTF_PROTO1|RTF_REJECT|RTF_BLACKHOLE; + r.hdr.rtm_seq = kr_state.rtseq++; /* overflow doesn't matter */ + r.hdr.rtm_addrs = RTA_DST|RTA_GATEWAY|RTA_NETMASK; + r.prefix.sin_len = sizeof(r.prefix); + r.prefix.sin_family = AF_INET; + r.prefix.sin_addr.s_addr = kroute->prefix.s_addr; + + r.nexthop.sin_len = sizeof(r.nexthop); + r.nexthop.sin_family = AF_INET; + r.nexthop.sin_addr.s_addr = kroute->nexthop.s_addr; + if (kroute->nexthop.s_addr != 0) + r.hdr.rtm_flags |= RTF_GATEWAY; + + r.mask.sin_len = sizeof(r.mask); + r.mask.sin_family = AF_INET; + r.mask.sin_addr.s_addr = kroute->netmask.s_addr; + +retry: + if (write(fd, &r, sizeof(r)) == -1) { + switch (errno) { + case ESRCH: + if (r.hdr.rtm_type == RTM_CHANGE) { + r.hdr.rtm_type = RTM_ADD; + goto retry; + } else if (r.hdr.rtm_type == RTM_DELETE) { + log_info("route %s/%u vanished before delete", + inet_ntoa(kroute->prefix), + mask2prefixlen(kroute->netmask.s_addr)); + return (0); + } else { + log_warnx("send_rtmsg: action %u, " + "prefix %s/%u: %s", r.hdr.rtm_type, + inet_ntoa(kroute->prefix), + mask2prefixlen(kroute->netmask.s_addr), + strerror(errno)); + return (0); + } + break; + default: + log_warnx("send_rtmsg: action %u, prefix %s/%u: %s", + r.hdr.rtm_type, inet_ntoa(kroute->prefix), + mask2prefixlen(kroute->netmask.s_addr), + strerror(errno)); + return (0); + } + } + + return (0); +} + +int +fetchtable(void) +{ + size_t len; + int mib[6]; + char *buf, *next, *lim; + struct rt_msghdr *rtm; + struct sockaddr *sa, *rti_info[RTAX_MAX]; + struct sockaddr_in *sa_in; + struct kroute_node *kr; + struct iface *iface = NULL; + + mib[0] = CTL_NET; + mib[1] = AF_ROUTE; + mib[2] = 0; + mib[3] = AF_INET; + mib[4] = NET_RT_DUMP; + mib[5] = 0; + + if (sysctl(mib, 6, NULL, &len, NULL, 0) == -1) { + log_warn("sysctl"); + return (-1); + } + if ((buf = malloc(len)) == NULL) { + log_warn("fetchtable"); + return (-1); + } + if (sysctl(mib, 6, buf, &len, NULL, 0) == -1) { + log_warn("sysctl"); + free(buf); + return (-1); + } + + lim = buf + len; + for (next = buf; next < lim; next += rtm->rtm_msglen) { + rtm = (struct rt_msghdr *)next; + sa = (struct sockaddr *)(rtm + 1); + get_rtaddrs(rtm->rtm_addrs, sa, rti_info); + + if ((sa = rti_info[RTAX_DST]) == NULL) + continue; + + if (rtm->rtm_flags & RTF_LLINFO) /* arp cache */ + continue; + +#ifdef RTF_MPATH + if (rtm->rtm_flags & RTF_MPATH) /* multipath */ + continue; +#endif + + if ((kr = calloc(1, sizeof(struct kroute_node))) == NULL) { + log_warn("fetchtable"); + free(buf); + return (-1); + } + + kr->r.flags = F_KERNEL; + + switch (sa->sa_family) { + case AF_INET: + kr->r.prefix.s_addr = + ((struct sockaddr_in *)sa)->sin_addr.s_addr; + sa_in = (struct sockaddr_in *)rti_info[RTAX_NETMASK]; + if (rtm->rtm_flags & RTF_STATIC) + kr->r.flags |= F_STATIC; + if (rtm->rtm_flags & RTF_DYNAMIC) + kr->r.flags |= F_DYNAMIC; + if (rtm->rtm_flags & RTF_PROTO1) + kr->r.flags |= F_BGPD_INSERTED; + if (rtm->rtm_flags & RTF_PROTO2) + kr->r.flags |= F_OSPFD_INSERTED; + if (sa_in != NULL) { + if (sa_in->sin_len == 0) + break; + kr->r.netmask.s_addr = + sa_in->sin_addr.s_addr; + } else if (rtm->rtm_flags & RTF_HOST) + kr->r.netmask.s_addr = prefixlen2mask(32); + else + kr->r.netmask.s_addr = + prefixlen2mask(prefixlen_classful + (kr->r.prefix.s_addr)); + break; + default: + free(kr); + continue; + } + + kr->r.ifindex = rtm->rtm_index; + + iface = if_find_index(rtm->rtm_index); + if (iface != NULL) + kr->r.metric = iface->cost; + else + kr->r.metric = 1; + + if ((sa = rti_info[RTAX_GATEWAY]) != NULL) + switch (sa->sa_family) { + case AF_INET: + kr->r.nexthop.s_addr = + ((struct sockaddr_in *)sa)->sin_addr.s_addr; + break; + case AF_LINK: + kr->r.flags |= F_CONNECTED; + break; + } + + if (rtm->rtm_flags & RTF_PROTO3) { + send_rtmsg(kr_state.fd, RTM_DELETE, &kr->r); + free(kr); + } else + kroute_insert(kr); + + } + free(buf); + return (0); +} + +int +fetchifs(int ifindex) +{ + size_t len; + int mib[6]; + char *buf, *next, *lim; + struct if_msghdr ifm; + struct kif_node *kif; + struct sockaddr *sa, *rti_info[RTAX_MAX]; + struct sockaddr_dl *sdl; + + mib[0] = CTL_NET; + mib[1] = AF_ROUTE; + mib[2] = 0; + mib[3] = AF_INET; + mib[4] = NET_RT_IFLIST; + mib[5] = ifindex; + + if (sysctl(mib, 6, NULL, &len, NULL, 0) == -1) { + log_warn("sysctl"); + return (-1); + } + if ((buf = malloc(len)) == NULL) { + log_warn("fetchif"); + return (-1); + } + if (sysctl(mib, 6, buf, &len, NULL, 0) == -1) { + log_warn("sysctl"); + free(buf); + return (-1); + } + + lim = buf + len; + for (next = buf; next < lim; next += ifm.ifm_msglen) { + memcpy(&ifm, next, sizeof(ifm)); + if (ifm.ifm_type != RTM_IFINFO) + continue; + + sa = (struct sockaddr *)(next + sizeof(ifm)); + get_rtaddrs(ifm.ifm_addrs, sa, rti_info); + + if ((kif = calloc(1, sizeof(struct kif_node))) == NULL) { + log_warn("fetchifs"); + free(buf); + return (-1); + } + + kif->k.ifindex = ifm.ifm_index; + kif->k.flags = ifm.ifm_flags; + kif->k.link_state = ifm.ifm_data.ifi_link_state; + kif->k.media_type = ifm.ifm_data.ifi_type; + kif->k.baudrate = ifm.ifm_data.ifi_baudrate; + kif->k.mtu = ifm.ifm_data.ifi_mtu; + kif->k.nh_reachable = (kif->k.flags & IFF_UP) && + (ifm.ifm_data.ifi_link_state == LINK_STATE_UP || + (ifm.ifm_data.ifi_link_state == LINK_STATE_UNKNOWN && + ifm.ifm_data.ifi_type != IFT_CARP)); + if ((sa = rti_info[RTAX_IFP]) != NULL) + if (sa->sa_family == AF_LINK) { + sdl = (struct sockaddr_dl *)sa; + if (sdl->sdl_nlen >= sizeof(kif->k.ifname)) + memcpy(kif->k.ifname, sdl->sdl_data, + sizeof(kif->k.ifname) - 1); + else if (sdl->sdl_nlen > 0) + memcpy(kif->k.ifname, sdl->sdl_data, + sdl->sdl_nlen); + /* string already terminated via calloc() */ + } + + kif_insert(kif); + } + free(buf); + return (0); +} + +int +dispatch_rtmsg(void) +{ + char buf[RT_BUF_SIZE]; + ssize_t n; + char *next, *lim; + struct rt_msghdr *rtm; + struct if_msghdr ifm; + struct sockaddr *sa, *rti_info[RTAX_MAX]; + struct sockaddr_in *sa_in; + struct kroute_node *kr; + struct in_addr prefix, nexthop, netmask; + int flags; + u_short ifindex = 0; + + if ((n = read(kr_state.fd, &buf, sizeof(buf))) == -1) { + log_warn("dispatch_rtmsg: read error"); + return (-1); + } + + if (n == 0) { + log_warnx("routing socket closed"); + return (-1); + } + + lim = buf + n; + for (next = buf; next < lim; next += rtm->rtm_msglen) { + rtm = (struct rt_msghdr *)next; + + prefix.s_addr = 0; + netmask.s_addr = 0; + flags = F_KERNEL; + nexthop.s_addr = 0; + + if (rtm->rtm_type == RTM_ADD || rtm->rtm_type == RTM_CHANGE || + rtm->rtm_type == RTM_DELETE) { + sa = (struct sockaddr *)(rtm + 1); + get_rtaddrs(rtm->rtm_addrs, sa, rti_info); + + if (rtm->rtm_pid == kr_state.pid) /* cause by us */ + continue; + + if (rtm->rtm_errno) /* failed attempts... */ + continue; + + if (rtm->rtm_flags & RTF_LLINFO) /* arp cache */ + continue; + + switch (sa->sa_family) { + case AF_INET: + prefix.s_addr = + ((struct sockaddr_in *)sa)->sin_addr.s_addr; + sa_in = (struct sockaddr_in *) + rti_info[RTAX_NETMASK]; + if (sa_in != NULL) { + if (sa_in->sin_len != 0) + netmask.s_addr = + sa_in->sin_addr.s_addr; + } else if (rtm->rtm_flags & RTF_HOST) + netmask.s_addr = prefixlen2mask(32); + else + netmask.s_addr = + prefixlen2mask(prefixlen_classful( + prefix.s_addr)); + if (rtm->rtm_flags & RTF_STATIC) + flags |= F_STATIC; + if (rtm->rtm_flags & RTF_DYNAMIC) + flags |= F_DYNAMIC; + if (rtm->rtm_flags & RTF_PROTO1) + flags |= F_BGPD_INSERTED; + if (rtm->rtm_flags & RTF_PROTO2) + flags |= F_OSPFD_INSERTED; + break; + default: + continue; + } + + ifindex = rtm->rtm_index; + if ((sa = rti_info[RTAX_GATEWAY]) != NULL) { + switch (sa->sa_family) { + case AF_INET: + nexthop.s_addr = ((struct + sockaddr_in *)sa)->sin_addr.s_addr; + break; + case AF_LINK: + flags |= F_CONNECTED; + break; + } + } + } + + switch (rtm->rtm_type) { + case RTM_ADD: + case RTM_CHANGE: + if (nexthop.s_addr == 0 && !(flags & F_CONNECTED)) { + log_warnx("dispatch_rtmsg no nexthop for %s/%u", + inet_ntoa(prefix), + mask2prefixlen(netmask.s_addr)); + continue; + } + + if ((kr = kroute_find(prefix.s_addr, netmask.s_addr)) != + NULL) { + /* rip route overridden by kernel */ + /* pref is not checked because this is forced */ + if (kr->r.flags & F_RIPD_INSERTED) + flags |= F_RIPD_INSERTED; + if (kr->r.flags & F_REDISTRIBUTED) + flags |= F_REDISTRIBUTED; + kr->r.nexthop.s_addr = nexthop.s_addr; + kr->r.flags = flags; + kr->r.ifindex = ifindex; + + if (kif_validate(kr->r.ifindex)) + kr->r.flags &= ~F_DOWN; + else + kr->r.flags |= F_DOWN; + + /* just readd, the RDE will care */ + kr_redistribute(IMSG_NETWORK_ADD, &kr->r); + } else { + if ((kr = calloc(1, + sizeof(struct kroute_node))) == NULL) { + log_warn("dispatch_rtmsg"); + return (-1); + } + kr->r.prefix.s_addr = prefix.s_addr; + kr->r.netmask.s_addr = netmask.s_addr; + kr->r.nexthop.s_addr = nexthop.s_addr; + kr->r.flags = flags; + kr->r.ifindex = ifindex; + + kroute_insert(kr); + } + break; + case RTM_DELETE: + if ((kr = kroute_find(prefix.s_addr, netmask.s_addr)) == + NULL) + continue; + if (!(kr->r.flags & F_KERNEL)) + continue; + if (kr->r.flags & F_RIPD_INSERTED) + main_imsg_compose_rde(IMSG_KROUTE_GET, 0, + &kr->r, sizeof(struct kroute)); + if (kroute_remove(kr) == -1) + return (-1); + break; + case RTM_IFINFO: + memcpy(&ifm, next, sizeof(ifm)); + if_change(ifm.ifm_index, ifm.ifm_flags, + &ifm.ifm_data); + break; + case RTM_IFANNOUNCE: + if_announce(next); + break; + default: + /* ignore for now */ + break; + } + } + return (0); +} diff --git a/usr.sbin/ripd/log.c b/usr.sbin/ripd/log.c new file mode 100644 index 00000000000..e581250f667 --- /dev/null +++ b/usr.sbin/ripd/log.c @@ -0,0 +1,222 @@ +/* $OpenBSD: log.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <errno.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <syslog.h> +#include <unistd.h> + +#include "ripd.h" +#include "log.h" + +static const char * const procnames[] = { + "parent", + "ripe", + "rde" +}; + +int debug; + +void logit(int, const char *, ...); + +void +log_init(int n_debug) +{ + extern char *__progname; + + debug = n_debug; + + if (!debug) + openlog(__progname, LOG_PID | LOG_NDELAY, LOG_DAEMON); + + tzset(); +} + +void +logit(int pri, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + vlog(pri, fmt, ap); + va_end(ap); +} + +void +vlog(int pri, const char *fmt, va_list ap) +{ + char *nfmt; + + if (debug) { + /* best effort in out of mem situations */ + if (asprintf(&nfmt, "%s\n", fmt) == -1) { + vfprintf(stderr, fmt, ap); + fprintf(stderr, "\n"); + } else { + vfprintf(stderr, nfmt, ap); + free(nfmt); + } + fflush(stderr); + } else + vsyslog(pri, fmt, ap); +} + +void +log_warn(const char *emsg, ...) +{ + char *nfmt; + va_list ap; + + /* best effort to even work in out of memory situations */ + if (emsg == NULL) + logit(LOG_CRIT, "%s", strerror(errno)); + else { + va_start(ap, emsg); + + if (asprintf(&nfmt, "%s: %s", emsg, strerror(errno)) == -1) { + /* we tried it... */ + vlog(LOG_CRIT, emsg, ap); + logit(LOG_CRIT, "%s", strerror(errno)); + } else { + vlog(LOG_CRIT, nfmt, ap); + free(nfmt); + } + va_end(ap); + } +} + +void +log_warnx(const char *emsg, ...) +{ + va_list ap; + + va_start(ap, emsg); + vlog(LOG_CRIT, emsg, ap); + va_end(ap); +} + +void +log_info(const char *emsg, ...) +{ + va_list ap; + + va_start(ap, emsg); + vlog(LOG_INFO, emsg, ap); + va_end(ap); +} + +void +log_debug(const char *emsg, ...) +{ + va_list ap; + + if (debug) { + va_start(ap, emsg); + vlog(LOG_DEBUG, emsg, ap); + va_end(ap); + } +} + +void +fatal(const char *emsg) +{ + if (emsg == NULL) + logit(LOG_CRIT, "fatal in %s: %s", procnames[ripd_process], + strerror(errno)); + else + if (errno) + logit(LOG_CRIT, "fatal in %s: %s: %s", + procnames[ripd_process], emsg, strerror(errno)); + else + logit(LOG_CRIT, "fatal in %s: %s", + procnames[ripd_process], emsg); + + if (ripd_process == PROC_MAIN) + exit(1); + else /* parent copes via SIGCHLD */ + _exit(1); +} + +void +fatalx(const char *emsg) +{ + errno = 0; + fatal(emsg); +} + +/* names */ +const char * +nbr_state_name(int state) +{ + switch (state) { + case NBR_STA_DOWN: + return ("DOWN"); + case NBR_STA_ACTIVE: + return ("ACTIVE"); + default: + return ("UNKNOWN"); + } +} + +const char * +if_type_name(enum iface_type type) +{ + switch (type) { + case IF_TYPE_POINTOPOINT: + return ("POINTOPOINT"); + case IF_TYPE_BROADCAST: + return ("BROADCAST"); + case IF_TYPE_NBMA: + return ("NBMA"); + case IF_TYPE_POINTOMULTIPOINT: + return ("POINTOMULTIPOINT"); + } + /* NOTREACHED */ + return ("UNKNOWN"); +} + +const char * +if_auth_name(enum auth_type type) +{ + switch (type) { + case AUTH_NONE: + return ("none"); + case AUTH_SIMPLE: + return ("simple"); + case AUTH_CRYPT: + return ("crypt"); + } + /* NOTREACHED */ + return ("unknown"); +} + +const char * +if_state_name(int state) +{ + switch (state) { + case IF_STA_DOWN: + return ("DOWN"); + case IF_STA_ACTIVE: + return ("ACTIVE"); + default: + return ("UNKNOWN"); + } +} diff --git a/usr.sbin/ripd/log.h b/usr.sbin/ripd/log.h new file mode 100644 index 00000000000..f1be0c23b55 --- /dev/null +++ b/usr.sbin/ripd/log.h @@ -0,0 +1,35 @@ +/* $OpenBSD: log.h,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _LOG_H_ +#define _LOG_H_ + +#include <stdarg.h> + +void log_init(int); +void vlog(int, const char *, va_list); +void log_warn(const char *, ...); +void log_warnx(const char *, ...); +void log_info(const char *, ...); +void log_debug(const char *, ...); +void fatal(const char *) __dead; +void fatalx(const char *) __dead; +const char *if_type_name(enum iface_type); +const char *nbr_state_name(int); + +#endif /* _LOG_H_ */ diff --git a/usr.sbin/ripd/neighbor.c b/usr.sbin/ripd/neighbor.c new file mode 100644 index 00000000000..edd33019bc2 --- /dev/null +++ b/usr.sbin/ripd/neighbor.c @@ -0,0 +1,357 @@ +/* $OpenBSD: neighbor.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org> + * Copyright (c) 2004, 2005, 2006 Esben Norby <norby@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <net/if.h> + +#include <ctype.h> +#include <err.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <event.h> + +#include "ripd.h" +#include "rip.h" +#include "ripe.h" +#include "log.h" +#include "rde.h" + +void nbr_start_timer(struct nbr *); +void nbr_reset_timer(struct nbr *); + +LIST_HEAD(nbr_head, nbr); + +struct nbr_table { + struct nbr_head *hashtbl; + u_int32_t hashmask; +} nbrtable; + +#define NBR_HASH(x) \ + &nbrtable.hashtbl[(x) & nbrtable.hashmask] + +u_int32_t peercnt = NBR_CNTSTART; + +struct { + int state; + enum nbr_event event; + enum nbr_action action; + int new_state; +} nbr_fsm_tbl[] = { + /* current state event that happened action to take resulting state */ + {NBR_STA_DOWN, NBR_EVT_REQUEST_RCVD, NBR_ACT_STRT_TIMER, NBR_STA_ACTIVE}, + {NBR_STA_DOWN, NBR_EVT_RESPONSE_RCVD, NBR_ACT_STRT_TIMER, NBR_STA_ACTIVE}, + {NBR_STA_ACTIVE, NBR_EVT_RESPONSE_RCVD, NBR_ACT_RST_TIMER, NBR_STA_ACTIVE}, + {NBR_STA_ACTIVE, NBR_EVT_REQUEST_RCVD, NBR_ACT_NOTHING, NBR_STA_ACTIVE}, + {NBR_STA_ACTIVE, NBR_EVT_TIMEOUT, NBR_ACT_DEL, NBR_STA_DOWN}, + {NBR_STA_ANY, NBR_EVT_KILL_NBR, NBR_ACT_DEL, NBR_STA_DOWN}, + {-1, NBR_EVT_NOTHING, NBR_ACT_NOTHING, 0}, +}; + +const char * const nbr_event_names[] = { + "RESPONSE RCVD", + "REQUEST RCVD", + "NBR TIMEOUT", + "NBR KILL", + "NOTHING" +}; + +const char * const nbr_action_names[] = { + "START TIMER", + "RESET TIMER", + "DELETE NBR", + "NOTHING" +}; + +int +nbr_fsm(struct nbr *nbr, enum nbr_event event) +{ + struct timeval now; + int old_state; + int new_state = 0; + int i; + + old_state = nbr->state; + for (i = 0; nbr_fsm_tbl[i].state != -1; i++) + if ((nbr_fsm_tbl[i].state & old_state) && + (nbr_fsm_tbl[i].event == event)) { + new_state = nbr_fsm_tbl[i].new_state; + break; + } + + if (nbr_fsm_tbl[i].state == -1) { + /* event outside of the defined fsm, ignore it. */ + log_warnx("nbr_fsm: neighbor ID %s, " + "event '%s' not expected in state '%s'", + inet_ntoa(nbr->id), nbr_event_name(event), + nbr_state_name(old_state)); + return (0); + } + + switch (nbr_fsm_tbl[i].action) { + case NBR_ACT_RST_TIMER: + nbr_reset_timer(nbr); + break; + case NBR_ACT_STRT_TIMER: + nbr_start_timer(nbr); + break; + case NBR_ACT_DEL: + nbr_act_del(nbr); + break; + case NBR_ACT_NOTHING: + /* do nothing */ + break; + } + + if (new_state != 0) + nbr->state = new_state; + + if (old_state != nbr->state) { + /* neighbor changed from/to ACTIVE */ + gettimeofday(&now, NULL); + nbr->uptime = now.tv_sec; + + log_debug("nbr_fsm: event '%s' resulted in action '%s' and " + "changing state for neighbor ID %s from '%s' to '%s'", + nbr_event_name(event), + nbr_action_name(nbr_fsm_tbl[i].action), + inet_ntoa(nbr->id), nbr_state_name(old_state), + nbr_state_name(nbr->state)); + } + + return (0); +} + +void +nbr_init(u_int32_t hashsize) +{ + u_int32_t hs, i; + + for (hs = 1; hs < hashsize; hs <<= 1) + ; + nbrtable.hashtbl = calloc(hs, sizeof(struct nbr_head)); + if (nbrtable.hashtbl == NULL) + fatal("nbr_init"); + + for (i = 0; i < hs; i++) + LIST_INIT(&nbrtable.hashtbl[i]); + + nbrtable.hashmask = hs - 1; +} + +struct nbr * +nbr_new(u_int32_t nbr_id, struct iface *iface, int self) +{ + struct nbr_head *head; + struct nbr *nbr = NULL; + + if ((nbr = calloc(1, sizeof(*nbr))) == NULL) + fatal("nbr_new"); + + nbr->state = NBR_STA_DOWN; + nbr->id.s_addr = nbr_id; + + /* get next unused peerid */ + while (nbr_find_peerid(++peercnt)) + ; + nbr->peerid = peercnt; + head = NBR_HASH(nbr->peerid); + LIST_INSERT_HEAD(head, nbr, hash); + + /* add to peer list */ + nbr->iface = iface; + LIST_INSERT_HEAD(&iface->nbr_list, nbr, entry); + + TAILQ_INIT(&nbr->rp_list); + TAILQ_INIT(&nbr->rq_list); + + /* set event structures */ + evtimer_set(&nbr->timeout_timer, nbr_timeout_timer, nbr); + + log_debug("nbr_new: neighbor ID %s, peerid %lu", + inet_ntoa(nbr->id), nbr->peerid); + + return (nbr); +} + +void +nbr_act_del(struct nbr *nbr) +{ + struct nbr_failed *nbr_failed; + struct iface *iface; + + if (nbr->iface->auth_type == AUTH_CRYPT) { + if ((nbr_failed = calloc(1, sizeof(*nbr_failed))) == NULL) + fatal("nbr_act_del"); + + nbr_failed->addr = nbr->addr; + nbr_failed->auth_seq_num = nbr->auth_seq_num; + iface = nbr->iface; + LIST_INSERT_HEAD(&iface->failed_nbr_list, + nbr_failed, entry); + } + + log_debug("nbr_del: neighbor ID %s, peerid %lu", inet_ntoa(nbr->id), + nbr->peerid); + + /* clear lists */ + //response_list_clr(&nbr->rr_list); + + LIST_REMOVE(nbr, entry); + LIST_REMOVE(nbr, hash); + + free(nbr); +} + +struct nbr * +nbr_find_peerid(u_int32_t peerid) +{ + struct nbr_head *head; + struct nbr *nbr; + + head = NBR_HASH(peerid); + + LIST_FOREACH(nbr, head, hash) { + if (nbr->peerid == peerid) + return (nbr); + } + + return (NULL); +} + +struct nbr * +nbr_find_ip(struct iface *iface, u_int32_t src_ip) +{ + struct nbr *nbr = NULL; + + LIST_FOREACH(nbr, &iface->nbr_list, entry) { + if (nbr->id.s_addr == src_ip) { + return (nbr); + } + } + + return (NULL); +} + +struct nbr_failed * +nbr_failed_find(struct iface *iface, u_int32_t src_ip) +{ + struct nbr_failed *nbr_failed = NULL; + + LIST_FOREACH(nbr_failed, &iface->failed_nbr_list, entry) { + if (nbr_failed->addr.s_addr == src_ip) { + return (nbr_failed); + } + } + + return (NULL); +} + +void +nbr_failed_delete(struct iface *iface, struct nbr_failed *nbr_failed) +{ + LIST_REMOVE(nbr_failed, entry); + + free(nbr_failed); +} + +/* timers */ +/* ARGSUSED */ +void +nbr_timeout_timer(int fd, short event, void *arg) +{ + struct nbr *nbr = arg; + + nbr_fsm(nbr, NBR_EVT_TIMEOUT); +} + +/* actions */ +void +nbr_reset_timer(struct nbr *nbr) +{ + struct timeval tv; + + timerclear(&tv); + tv.tv_sec = NBR_TIMEOUT; + + if (evtimer_add(&nbr->timeout_timer, &tv) == -1) + fatal("nbr_reset_timer"); +} + +void +nbr_start_timer(struct nbr *nbr) +{ + struct timeval tv; + + timerclear(&tv); + tv.tv_sec = NBR_TIMEOUT; + + if (evtimer_add(&nbr->timeout_timer, &tv) == -1) + fatal("nbr_start_timer"); +} + +/* names */ +const char * +nbr_event_name(int event) +{ + return (nbr_event_names[event]); +} + +const char * +nbr_action_name(int action) +{ + return (nbr_action_names[action]); +} + +struct ctl_nbr * +nbr_to_ctl(struct nbr *nbr) +{ + static struct ctl_nbr nctl; + struct timeval tv, now, res; + + memcpy(nctl.name, nbr->iface->name, sizeof(nctl.name)); + memcpy(&nctl.id, &nbr->id, sizeof(nctl.id)); + memcpy(&nctl.addr, &nbr->addr, sizeof(nctl.addr)); + + nctl.nbr_state = nbr->state; + nctl.iface_state = nbr->iface->state; + + gettimeofday(&now, NULL); + if (evtimer_pending(&nbr->timeout_timer, &tv)) { + timersub(&tv, &now, &res); + if (nbr->state & NBR_STA_DOWN) + nctl.dead_timer = NBR_TIMEOUT - res.tv_sec; + else + nctl.dead_timer = res.tv_sec; + } else + nctl.dead_timer = 0; + + if (nbr->state == NBR_STA_ACTIVE) { + nctl.uptime = now.tv_sec - nbr->uptime; + } else + nctl.uptime = 0; + + return (&nctl); +} diff --git a/usr.sbin/ripd/packet.c b/usr.sbin/ripd/packet.c new file mode 100644 index 00000000000..6b812f34ccf --- /dev/null +++ b/usr.sbin/ripd/packet.c @@ -0,0 +1,251 @@ +/* $OpenBSD: packet.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/uio.h> + +#include <netinet/in.h> +#include <netinet/in_systm.h> +#include <netinet/ip.h> +#include <netinet/udp.h> +#include <arpa/inet.h> + +#include <net/if_dl.h> + +#include <errno.h> +#include <event.h> +#include <stdlib.h> +#include <string.h> + +#include "ripd.h" +#include "rip.h" +#include "log.h" +#include "ripe.h" + +int rip_hdr_sanity_check(struct rip_hdr *); +struct iface *find_iface(struct ripd_conf *, unsigned int, struct in_addr); + +int +gen_rip_hdr(struct buf *buf, u_int8_t command) +{ + struct rip_hdr rip_hdr; + + bzero(&rip_hdr, sizeof(rip_hdr)); + rip_hdr.version = RIP_VERSION; + rip_hdr.command = command; + + return (buf_add(buf, &rip_hdr, sizeof(rip_hdr))); +} + +/* send and receive packets */ +int +send_packet(struct iface *iface, void *pkt, size_t len, struct sockaddr_in *dst) +{ + /* set outgoing interface for multicast traffic */ + if (IN_MULTICAST(ntohl(dst->sin_addr.s_addr))) + if (if_set_mcast(iface) == -1) { + log_warn("send_packet: error setting multicast " + "interface, %s", iface->name); + return (-1); + } + + if (sendto(iface->fd, pkt, len, 0, + (struct sockaddr *)dst, sizeof(*dst)) == -1) { + log_warn("send_packet: error sending packet on interface %s", + iface->name); + return (-1); + } + + return (0); +} + +void +recv_packet(int fd, short event, void *bula) +{ + char cbuf[CMSG_SPACE(sizeof(struct sockaddr_dl))]; + struct sockaddr_in src; + struct iovec iov; + struct msghdr msg; + struct cmsghdr *cmsg; + struct sockaddr_dl *dst = NULL; + struct nbr_failed *nbr_failed = NULL; + struct ripd_conf *xconf = bula; + struct iface *iface; + struct rip_hdr *rip_hdr; + struct nbr *nbr; + char *buf; + ssize_t r; + u_int16_t len, srcport; + u_int32_t auth_crypt_num = 0; + + if (event != EV_READ) + return; + + /* setup buffer */ + buf = pkt_ptr; + + bzero(&msg, sizeof(msg)); + + iov.iov_base = buf; + iov.iov_len = READ_BUF_SIZE; + msg.msg_name = &src; + msg.msg_namelen = sizeof(src); + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_control = cbuf; + msg.msg_controllen = sizeof(cbuf); + + if ((r = recvmsg(fd, &msg, 0)) == -1) { + if (errno != EINTR && errno != EAGAIN) + log_debug("recv_packet: read error: %s", + strerror(errno)); + return; + } + + for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; + cmsg = CMSG_NXTHDR(&msg, cmsg)) { + if (cmsg->cmsg_level == IPPROTO_IP && + cmsg->cmsg_type == IP_RECVIF) { + dst = (struct sockaddr_dl *)CMSG_DATA(cmsg); + break; + } + } + + if (dst == NULL) + return; + + len = (u_int16_t)r; + + /* Check the packet is not from one of the local interfaces */ + LIST_FOREACH(iface, &xconf->iface_list, entry) { + if (iface->addr.s_addr == src.sin_addr.s_addr) + return; + } + + /* find a matching interface */ + if ((iface = find_iface(xconf, dst->sdl_index, src.sin_addr)) == NULL) { + log_debug("recv_packet: cannot find a matching interface"); + return; + } + + srcport = ntohs(src.sin_port); + + /* RIP header sanity checks */ + if (len < RIP_HDR_LEN) { + log_debug("recv_packet: bad packet size"); + return; + } + rip_hdr = (struct rip_hdr *)buf; + + if (rip_hdr_sanity_check(rip_hdr) == -1) + return; + + nbr = nbr_find_ip(iface, src.sin_addr.s_addr); + + if (nbr == NULL && iface->auth_type == AUTH_CRYPT) + nbr_failed = nbr_failed_find(iface, src.sin_addr.s_addr); + + /* switch RIP command */ + switch (rip_hdr->command) { + case COMMAND_REQUEST: + if ((msg.msg_flags & MSG_MCAST) == 0 && srcport == RIP_PORT) + return; + + /* XXX: it would be better to not create a nbr on request + * becouse this could lead to DoS even on a authenticated + * environment. + */ + if (nbr == NULL) { + nbr = nbr_new(src.sin_addr.s_addr, iface, 0); + if (nbr_failed != NULL) { + nbr->auth_seq_num = nbr_failed->auth_seq_num; + nbr_failed_delete(iface, nbr_failed); + } + nbr->addr = src.sin_addr; + } + nbr->port = srcport; + nbr_fsm(nbr, NBR_EVT_REQUEST_RCVD); + + buf += RIP_HDR_LEN; + len -= RIP_HDR_LEN; + + recv_request(iface, nbr, buf, len); + break; + case COMMAND_RESPONSE: + if (srcport != RIP_PORT) + return; + + if (auth_validate(&buf, &len, iface, nbr, nbr_failed, + &auth_crypt_num)) { + log_warnx("recv_packet: authentication error, " + "interface %s", iface->name); + return; + } + + if (nbr == NULL) { + nbr = nbr_new(src.sin_addr.s_addr, iface, 0); + if (nbr_failed != NULL) + nbr_failed_delete(iface, nbr_failed); + nbr->addr = src.sin_addr; + } + nbr->auth_seq_num = auth_crypt_num; + nbr_fsm(nbr, NBR_EVT_RESPONSE_RCVD); + + recv_response(iface, nbr, buf, len); + break; + default: + log_debug("recv_packet: unknown RIP command, interface %s", + iface->name); + } +} + +int +rip_hdr_sanity_check(struct rip_hdr *rip_hdr) +{ + if (rip_hdr->version != RIP_VERSION) { + log_debug("recv_packet: invalid RIP version %d", + rip_hdr->version); + return (-1); + } + + return (0); +} + +struct iface * +find_iface(struct ripd_conf *xconf, unsigned int ifindex, struct in_addr src) +{ + struct iface *iface = NULL; + + /* returned interface needs to be active */ + LIST_FOREACH(iface, &xconf->iface_list, entry) { + if (ifindex != 0 && ifindex == iface->ifindex && + !iface->passive && (iface->addr.s_addr & + iface->mask.s_addr) == (src.s_addr & iface->mask.s_addr)) + /* + * XXX may fail on P2P links because src and dst don't + * have to share a common subnet on the otherhand + * checking somthing like this will help to support + * multiple networks configured on one interface. + */ + return (iface); + } + + return (NULL); +} diff --git a/usr.sbin/ripd/parse.y b/usr.sbin/ripd/parse.y new file mode 100644 index 00000000000..e5e98ca8b18 --- /dev/null +++ b/usr.sbin/ripd/parse.y @@ -0,0 +1,763 @@ +/* $OpenBSD: parse.y,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org> + * Copyright (c) 2004 Ryan McBride <mcbride@openbsd.org> + * Copyright (c) 2002, 2003, 2004 Henning Brauer <henning@openbsd.org> + * Copyright (c) 2001 Markus Friedl. All rights reserved. + * Copyright (c) 2001 Daniel Hartmeier. All rights reserved. + * Copyright (c) 2001 Theo de Raadt. All rights reserved. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +%{ +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <ctype.h> +#include <err.h> +#include <errno.h> +#include <ifaddrs.h> +#include <limits.h> +#include <stdarg.h> +#include <stdio.h> +#include <string.h> + +#include "ripd.h" +#include "rip.h" +#include "ripe.h" +#include "log.h" + +static struct ripd_conf *conf; +static FILE *fin = NULL; +static int lineno = 1; +static int errors = 0; +static int pdebug = 1; +char *infile; +char *start_state; + +struct iface *iface = NULL; + +int yyerror(const char *, ...); +int yyparse(void); +int kw_cmp(const void *, const void *); +int lookup(char *); +int lgetc(FILE *); +int lungetc(int); +int findeol(void); +int yylex(void); +void clear_config(struct ripd_conf *); +int check_file_secrecy(int fd, const char *fname); +u_int32_t get_rtr_id(void); + +static struct { + char auth_key[MAX_SIMPLE_AUTH_LEN]; + struct auth_md_head md_list; + enum auth_type auth_type; + u_int8_t auth_keyid; + u_int8_t cost; +} *defs, globaldefs, ifacedefs; + +TAILQ_HEAD(symhead, sym) symhead = TAILQ_HEAD_INITIALIZER(symhead); +struct sym { + TAILQ_ENTRY(sym) entries; + int used; + int persist; + char *nam; + char *val; +}; + +int symset(const char *, const char *, int); +char *symget(const char *); +int atoul(char *, u_long *); +struct iface *conf_get_if(struct kif *); + +typedef struct { + union { + u_int32_t number; + char *string; + } v; + int lineno; +} YYSTYPE; + +%} + +%token SPLIT_HORIZON TRIGGERED_UPDATES FIBUPDATE REDISTRIBUTE +%token AUTHKEY AUTHTYPE AUTHMD AUTHMDKEYID +%token INTERFACE +%token COST PASSIVE +%token ERROR +%token <v.string> STRING +%type <v.number> number yesno +%type <v.string> string + +%% + +grammar : /* empty */ + | grammar '\n' + | grammar conf_main '\n' + | grammar varset '\n' + | grammar interface '\n' + ; + +number : STRING { + u_long ulval; + + if (atoul($1, &ulval) == -1) { + yyerror("%s is not a number", $1); + free($1); + YYERROR; + } else + $$ = ulval; + free($1); + } + ; + +string : string STRING { + if (asprintf(&$$, "%s %s", $1, $2) == -1) { + free($1); + free($2); + yyerror("string: asprintf"); + YYERROR; + } + free($1); + free($2); + } + | STRING + ; + +yesno : STRING { + if (!strcmp($1, "yes")) + $$ = 1; + else if (!strcmp($1, "no")) + $$ = 0; + else { + free($1); + yyerror("recognized values are yes or no"); + YYERROR; + } + free($1); + } + ; + +varset : STRING '=' string { + if (conf->opts & RIPD_OPT_VERBOSE) + printf("%s = \"%s\"\n", $1, $3); + if (symset($1, $3, 0) == -1) + fatal("cannot store variable"); + free($1); + free($3); + } + ; + +conf_main : SPLIT_HORIZON STRING { + /* clean flags first */ + conf->options &= ~(OPT_SPLIT_HORIZON | + OPT_SPLIT_POISONED); + if (!strcmp($2, "none")) + /* nothing */ ; + else if (!strcmp($2, "default")) + conf->options |= OPT_SPLIT_HORIZON; + else if (!strcmp($2, "poisoned")) + conf->options |= OPT_SPLIT_POISONED; + else { + yyerror("unknon split horizon type"); + free($2); + YYERROR; + } + free($2); + } + | TRIGGERED_UPDATES yesno { + if ($2 == 1) + conf->options |= OPT_TRIGGERED_UPDATES; + else + conf->options &= ~OPT_TRIGGERED_UPDATES; + } + | FIBUPDATE yesno { + if ($2 == 0) + conf->flags |= RIPD_FLAG_NO_FIB_UPDATE; + else + conf->flags &= ~RIPD_FLAG_NO_FIB_UPDATE; + } + | REDISTRIBUTE STRING { + if (!strcmp($2, "static")) + conf->redistribute_flags |= + REDISTRIBUTE_STATIC; + else if (!strcmp($2, "connected")) + conf->redistribute_flags |= + REDISTRIBUTE_CONNECTED; + else if (!strcmp($2, "default")) + conf->redistribute_flags |= + REDISTRIBUTE_DEFAULT; + else if (!strcmp($2, "none")) + conf->redistribute_flags = 0; + else { + yyerror("unknown redistribute type"); + free($2); + YYERROR; + } + free($2); + } + ; + +authmd : AUTHMD number STRING { + if ($2 < MIN_MD_ID || $2 > MAX_MD_ID) { + yyerror("auth-md key-id out of range " + "(%d-%d)", MIN_MD_ID, MAX_MD_ID); + free($3); + YYERROR; + } + if (strlen($3) > MD5_DIGEST_LENGTH) { + yyerror("auth-md key length out of range " + "(max length %d)", + MD5_DIGEST_LENGTH); + free($3); + YYERROR; + } + md_list_add(&defs->md_list, $2, $3); + free($3); + } + +authmdkeyid : AUTHMDKEYID number { + if ($2 < MIN_MD_ID || $2 > MAX_MD_ID) { + yyerror("auth-md-keyid out of range " + "(%d-%d)", MIN_MD_ID, MAX_MD_ID); + YYERROR; + } + defs->auth_keyid = $2; + } + +authtype : AUTHTYPE STRING { + enum auth_type type; + + if (!strcmp($2, "none")) + type = AUTH_NONE; + else if (!strcmp($2, "simple")) + type = AUTH_SIMPLE; + else if (!strcmp($2, "crypt")) + type = AUTH_CRYPT; + else { + yyerror("unknown auth-type"); + free($2); + YYERROR; + } + free($2); + defs->auth_type = type; + } + ; + +authkey : AUTHKEY STRING { + if (strlen($2) > MAX_SIMPLE_AUTH_LEN) { + yyerror("auth-key too long (max lenght %d)", + MAX_SIMPLE_AUTH_LEN); + free($2); + YYERROR; + } + strncpy(defs->auth_key, $2, + sizeof(defs->auth_key)); + free($2); + } + ; + +defaults : COST number { + if ($2 < 1 || $2 > INFINITY) { + yyerror("cost out of range (%d-%d)", 1, + INFINITY); + YYERROR; + } + defs->cost = $2; + } + | authtype + | authkey + | authmdkeyid + | authmd + ; + +optnl : '\n' optnl + | + ; + +nl : '\n' optnl + ; + +interface : INTERFACE STRING { + struct kif *kif; + + if ((kif = kif_findname($2)) == NULL) { + yyerror("unknown interface %s", $2); + free($2); + YYERROR; + } + free($2); + iface = conf_get_if(kif); + if (iface == NULL) + YYERROR; + LIST_INSERT_HEAD(&conf->iface_list, iface, entry); + memcpy(&ifacedefs, defs, sizeof(ifacedefs)); + md_list_copy(&ifacedefs.md_list, + &defs->md_list); + defs = &ifacedefs; + } interface_block { + iface->cost = defs->cost; + iface->auth_type = defs->auth_type; + iface->auth_keyid = defs->auth_keyid; + memcpy(iface->auth_key, defs->auth_key, + sizeof(iface->auth_key)); + md_list_copy(&iface->auth_md_list, &defs->md_list); + md_list_clr(&defs->md_list); + defs = &globaldefs; + } + ; + +interface_block : '{' optnl interfaceopts_l '}' + | '{' optnl '}' + ; + +interfaceopts_l : interfaceopts_l interfaceoptsl + | interfaceoptsl + ; + +interfaceoptsl : PASSIVE nl { iface->passive = 1; } + | defaults nl + ; +%% + +struct keywords { + const char *k_name; + int k_val; +}; + +int +yyerror(const char *fmt, ...) +{ + va_list ap; + + errors = 1; + va_start(ap, fmt); + fprintf(stderr, "%s:%d: ", infile, yylval.lineno); + vfprintf(stderr, fmt, ap); + fprintf(stderr, "\n"); + va_end(ap); + return (0); +} + +int +kw_cmp(const void *k, const void *e) +{ + return (strcmp(k, ((const struct keywords *)e)->k_name)); +} + +int +lookup(char *s) +{ + /* this has to be sorted always */ + static const struct keywords keywords[] = { + {"auth-key", AUTHKEY}, + {"auth-md", AUTHMD}, + {"auth-md-keyid", AUTHMDKEYID}, + {"auth-type", AUTHTYPE}, + {"cost", COST}, + {"fib-update", FIBUPDATE}, + {"interface", INTERFACE}, + {"passive", PASSIVE}, + {"redistribute", REDISTRIBUTE}, + {"split-horizon", SPLIT_HORIZON}, + {"triggered-updates", TRIGGERED_UPDATES} + }; + const struct keywords *p; + + p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]), + sizeof(keywords[0]), kw_cmp); + + if (p) { + if (pdebug > 1) + fprintf(stderr, "%s: %d\n", s, p->k_val); + return (p->k_val); + } else { + if (pdebug > 1) + fprintf(stderr, "string: %s\n", s); + return (STRING); + } +} + +#define MAXPUSHBACK 128 + +char *parsebuf; +int parseindex; +char pushback_buffer[MAXPUSHBACK]; +int pushback_index = 0; + +int +lgetc(FILE *f) +{ + int c, next; + + if (parsebuf) { + /* Read character from the parsebuffer instead of input. */ + if (parseindex >= 0) { + c = parsebuf[parseindex++]; + if (c != '\0') + return (c); + parsebuf = NULL; + } else + parseindex++; + } + + if (pushback_index) + return (pushback_buffer[--pushback_index]); + + while ((c = getc(f)) == '\\') { + next = getc(f); + if (next != '\n') { + if (isspace(next)) + yyerror("whitespace after \\"); + ungetc(next, f); + break; + } + yylval.lineno = lineno; + lineno++; + } + if (c == '\t' || c == ' ') { + /* Compress blanks to a single space. */ + do { + c = getc(f); + } while (c == '\t' || c == ' '); + ungetc(c, f); + c = ' '; + } + + return (c); +} + +int +lungetc(int c) +{ + if (c == EOF) + return (EOF); + if (parsebuf) { + parseindex--; + if (parseindex >= 0) + return (c); + } + if (pushback_index < MAXPUSHBACK-1) + return (pushback_buffer[pushback_index++] = c); + else + return (EOF); +} + +int +findeol(void) +{ + int c; + + parsebuf = NULL; + pushback_index = 0; + + /* skip to either EOF or the first real EOL */ + while (1) { + c = lgetc(fin); + if (c == '\n') { + lineno++; + break; + } + if (c == EOF) + break; + } + return (ERROR); +} + +int +yylex(void) +{ + char buf[8096]; + char *p, *val; + int endc, c; + int token; + +top: + p = buf; + while ((c = lgetc(fin)) == ' ') + ; /* nothing */ + + yylval.lineno = lineno; + if (c == '#') + while ((c = lgetc(fin)) != '\n' && c != EOF) + ; /* nothing */ + if (c == '$' && parsebuf == NULL) { + while (1) { + if ((c = lgetc(fin)) == EOF) + return (0); + + if (p + 1 >= buf + sizeof(buf) - 1) { + yyerror("string too long"); + return (findeol()); + } + if (isalnum(c) || c == '_') { + *p++ = (char)c; + continue; + } + *p = '\0'; + lungetc(c); + break; + } + val = symget(buf); + if (val == NULL) { + yyerror("macro '%s' not defined", buf); + return (findeol()); + } + parsebuf = val; + parseindex = 0; + goto top; + } + + switch (c) { + case '\'': + case '"': + endc = c; + while (1) { + if ((c = lgetc(fin)) == EOF) + return (0); + if (c == endc) { + *p = '\0'; + break; + } + if (c == '\n') { + lineno++; + continue; + } + if (p + 1 >= buf + sizeof(buf) - 1) { + yyerror("string too long"); + return (findeol()); + } + *p++ = (char)c; + } + yylval.v.string = strdup(buf); + if (yylval.v.string == NULL) + errx(1, "yylex: strdup"); + return (STRING); + } + +#define allowed_in_string(x) \ + (isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \ + x != '{' && x != '}' && \ + x != '!' && x != '=' && x != '#' && \ + x != ',')) + + if (isalnum(c) || c == ':' || c == '_') { + do { + *p++ = c; + if ((unsigned)(p-buf) >= sizeof(buf)) { + yyerror("string too long"); + return (findeol()); + } + } while ((c = lgetc(fin)) != EOF && (allowed_in_string(c))); + lungetc(c); + *p = '\0'; + if ((token = lookup(buf)) == STRING) + if ((yylval.v.string = strdup(buf)) == NULL) + err(1, "yylex: strdup"); + return (token); + } + if (c == '\n') { + yylval.lineno = lineno; + lineno++; + } + if (c == EOF) + return (0); + return (c); +} + +struct ripd_conf * +parse_config(char *filename, int opts) +{ + struct sym *sym, *next; + + if ((conf = calloc(1, sizeof(struct ripd_conf))) == NULL) + fatal("parse_config"); + + bzero(&globaldefs, sizeof(globaldefs)); + defs = &globaldefs; + TAILQ_INIT(&defs->md_list); + defs->cost = 1; + defs->auth_type = AUTH_NONE; + + if ((fin = fopen(filename, "r")) == NULL) { + warn("%s", filename); + free(conf); + return (NULL); + } + infile = filename; + + conf->opts = opts; + conf->redistribute_flags = 0; + + if (!(conf->opts & RIPD_OPT_NOACTION)) + if (check_file_secrecy(fileno(fin), filename)) { + fclose(fin); + free(conf); + return (NULL); + } + + yyparse(); + + fclose(fin); + + /* Free macros and check which have not been used. */ + for (sym = TAILQ_FIRST(&symhead); sym != NULL; sym = next) { + next = TAILQ_NEXT(sym, entries); + if ((conf->opts & RIPD_OPT_VERBOSE2) && !sym->used) + fprintf(stderr, "warning: macro '%s' not " + "used\n", sym->nam); + if (!sym->persist) { + free(sym->nam); + free(sym->val); + TAILQ_REMOVE(&symhead, sym, entries); + free(sym); + } + } + + /* free global config defaults */ + md_list_clr(&globaldefs.md_list); + + if (errors) { + clear_config(conf); + return (NULL); + } + + return (conf); +} + +int +symset(const char *nam, const char *val, int persist) +{ + struct sym *sym; + + for (sym = TAILQ_FIRST(&symhead); sym && strcmp(nam, sym->nam); + sym = TAILQ_NEXT(sym, entries)) + ; /* nothing */ + + if (sym != NULL) { + if (sym->persist == 1) + return (0); + else { + free(sym->nam); + free(sym->val); + TAILQ_REMOVE(&symhead, sym, entries); + free(sym); + } + } + if ((sym = calloc(1, sizeof(*sym))) == NULL) + return (-1); + + sym->nam = strdup(nam); + if (sym->nam == NULL) { + free(sym); + return (-1); + } + sym->val = strdup(val); + if (sym->val == NULL) { + free(sym->nam); + free(sym); + return (-1); + } + sym->used = 0; + sym->persist = persist; + TAILQ_INSERT_TAIL(&symhead, sym, entries); + return (0); +} + +int +cmdline_symset(char *s) +{ + char *sym, *val; + int ret; + size_t len; + + if ((val = strrchr(s, '=')) == NULL) + return (-1); + + len = strlen(s) - strlen(val) + 1; + if ((sym = malloc(len)) == NULL) + errx(1, "cmdline_symset: malloc"); + + strlcpy(sym, s, len); + + ret = symset(sym, val + 1, 1); + free(sym); + + return (ret); +} + +char * +symget(const char *nam) +{ + struct sym *sym; + + TAILQ_FOREACH(sym, &symhead, entries) + if (strcmp(nam, sym->nam) == 0) { + sym->used = 1; + return (sym->val); + } + return (NULL); +} + +int +atoul(char *s, u_long *ulvalp) +{ + u_long ulval; + char *ep; + + errno = 0; + ulval = strtoul(s, &ep, 0); + if (s[0] == '\0' || *ep != '\0') + return (-1); + if (errno == ERANGE && ulval == ULONG_MAX) + return (-1); + *ulvalp = ulval; + return (0); +} + +struct iface * +conf_get_if(struct kif *kif) +{ + struct iface *i; + + LIST_FOREACH(i, &conf->iface_list, entry) + if (i->ifindex == kif->ifindex) { + yyerror("interface %s already configured", + kif->ifname); + return (NULL); + } + + i = if_new(kif); + i->auth_keyid = 1; + i->passive = 0; + + return (i); +} + +void +clear_config(struct ripd_conf *xconf) +{ + struct iface *i; + + while ((i = LIST_FIRST(&conf->iface_list)) != NULL) { + LIST_REMOVE(i, entry); + if_del(i); + } + + free(xconf); +} diff --git a/usr.sbin/ripd/printconf.c b/usr.sbin/ripd/printconf.c new file mode 100644 index 00000000000..a87cde902f3 --- /dev/null +++ b/usr.sbin/ripd/printconf.c @@ -0,0 +1,106 @@ +/* $OpenBSD: printconf.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2004, 2005, 2006 Esben Norby <norby@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/queue.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> + +#include <stdio.h> + +#include "rip.h" +#include "ripd.h" +#include "ripe.h" + +void print_mainconf(struct ripd_conf *); +void print_iface(struct iface *); + +void +print_mainconf(struct ripd_conf *conf) +{ + if (conf->flags |= RIPD_FLAG_NO_FIB_UPDATE) + printf("fib-update yes\n"); + else + printf("fib-update no\n"); + + if (conf->redistribute_flags & REDISTRIBUTE_STATIC) + printf("redistribute static\n"); + else if (conf->redistribute_flags & REDISTRIBUTE_CONNECTED) + printf("redistribute connected\n"); + else if (conf->redistribute_flags & REDISTRIBUTE_DEFAULT) + printf("redistribute default\n"); + else + printf("redistribute none\n"); + + if (conf->options & OPT_SPLIT_HORIZON) + printf("split-horizon default\n"); + else if (conf->options & OPT_SPLIT_POISONED) + printf("split-horizon poisoned\n"); + else + printf("split-horizon none\n"); + + if (conf->options & OPT_TRIGGERED_UPDATES) + printf("triggered-updates yes\n"); + else + printf("triggered-updates no\n"); +} + +void +print_iface(struct iface *iface) +{ + printf("interface %s {\n", iface->name); + + if (iface->passive) + printf("\tpassive\n"); + + printf("\tcost %d\n", iface->cost); + + printf("\tauth-type %s\n", if_auth_name(iface->auth_type)); + switch (iface->auth_type) { + case AUTH_NONE: + break; + case AUTH_SIMPLE: + printf("\tauth-key XXXXXX\n"); + break; + case AUTH_CRYPT: + break; + default: + printf("\tunknown auth type!\n"); + break; + } + + printf("}\n"); +} + +void +print_config(struct ripd_conf *conf) +{ + struct iface *iface; + + printf("\n"); + print_mainconf(conf); + printf("\n"); + + LIST_FOREACH(iface, &conf->iface_list, entry) { + printf("ooo\n"); + print_iface(iface); + } + printf("\n"); + +} diff --git a/usr.sbin/ripd/rde.c b/usr.sbin/ripd/rde.c new file mode 100644 index 00000000000..262eff65309 --- /dev/null +++ b/usr.sbin/ripd/rde.c @@ -0,0 +1,455 @@ +/* $OpenBSD: rde.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2004, 2005 Claudio Jeker <claudio@openbsd.org> + * Copyright (c) 2004 Esben Norby <norby@openbsd.org> + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/queue.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <err.h> +#include <errno.h> +#include <stdlib.h> +#include <signal.h> +#include <string.h> +#include <pwd.h> +#include <unistd.h> +#include <event.h> + +#include "ripd.h" +#include "rip.h" +#include "ripe.h" +#include "log.h" +#include "rde.h" + +struct ripd_conf *rdeconf = NULL; +struct imsgbuf *ibuf_ripe; +struct imsgbuf *ibuf_main; + +void rde_sig_handler(int, short, void *); +void rde_shutdown(void); +void rde_dispatch_imsg(int, short, void *); +void rde_dispatch_parent(int, short, void *); +int rde_imsg_compose_parent(int, pid_t, void *, u_int16_t); +int rde_imsg_compose_ripe(int, u_int32_t, pid_t, void *, u_int16_t); +int rde_check_route(struct rip_route *); +void triggered_update(struct rt_node *); + +/* ARGSUSED */ +void +rde_sig_handler(int sig, short event, void *arg) +{ + /* + * signal handler rules don't apply, libevent decouples for us + */ + + switch (sig) { + case SIGINT: + case SIGTERM: + rde_shutdown(); + /* NOTREACHED */ + default: + fatalx("unexpected signal"); + } +} + +/* route decision engine */ +pid_t +rde(struct ripd_conf *xconf, int pipe_parent2rde[2], int pipe_ripe2rde[2], + int pipe_parent2ripe[2]) +{ + struct passwd *pw; + struct event ev_sigint, ev_sigterm; + pid_t pid; + + switch (pid = fork()) { + case -1: + fatal("cannot fork"); + /* NOTREACHED */ + case 0: + break; + default: + return (pid); + } + + rdeconf = xconf; + + if ((pw = getpwnam(RIPD_USER)) == NULL) + fatal("getpwnam"); + + if (chroot(pw->pw_dir) == -1) + fatal("chroot"); + if (chdir("/") == -1) + fatal("chdir(\"/\")"); + + setproctitle("route decision engine"); + ripd_process = PROC_RDE_ENGINE; + + if (setgroups(1, &pw->pw_gid) || + setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) || + setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid)) + fatal("can't drop privileges"); + + event_init(); + + /* setup signal handler */ + signal_set(&ev_sigint, SIGINT, rde_sig_handler, NULL); + signal_set(&ev_sigterm, SIGTERM, rde_sig_handler, NULL); + signal_add(&ev_sigint, NULL); + signal_add(&ev_sigterm, NULL); + + /* setup pipes */ + close(pipe_ripe2rde[0]); + close(pipe_parent2rde[0]); + close(pipe_parent2ripe[0]); + close(pipe_parent2ripe[1]); + + if ((ibuf_ripe = malloc(sizeof(struct imsgbuf))) == NULL || + (ibuf_main = malloc(sizeof(struct imsgbuf))) == NULL) + fatal(NULL); + imsg_init(ibuf_ripe, pipe_ripe2rde[1], rde_dispatch_imsg); + imsg_init(ibuf_main, pipe_parent2rde[1], rde_dispatch_parent); + + /* setup event handler */ + ibuf_ripe->events = EV_READ; + event_set(&ibuf_ripe->ev, ibuf_ripe->fd, ibuf_ripe->events, + ibuf_ripe->handler, ibuf_ripe); + event_add(&ibuf_ripe->ev, NULL); + + ibuf_main->events = EV_READ; + event_set(&ibuf_main->ev, ibuf_main->fd, ibuf_main->events, + ibuf_main->handler, ibuf_main); + event_add(&ibuf_main->ev, NULL); + + rt_init(); + event_dispatch(); + + rde_shutdown(); + /* NOTREACHED */ + + return (0); +} + +void +rde_shutdown(void) +{ + rt_clear(); + + msgbuf_clear(&ibuf_ripe->w); + free(ibuf_ripe); + msgbuf_clear(&ibuf_main->w); + free(ibuf_main); + free(rdeconf); + + log_info("route decision engine exiting"); + _exit(0); +} + +/* imesg */ +int +rde_imsg_compose_parent(int type, pid_t pid, void *data, u_int16_t datalen) +{ + return (imsg_compose(ibuf_main, type, 0, pid, data, datalen)); +} + +int +rde_imsg_compose_ripe(int type, u_int32_t peerid, pid_t pid, void *data, + u_int16_t datalen) +{ + return (imsg_compose(ibuf_ripe, type, peerid, pid, data, datalen)); +} + +/* ARGSUSED */ +void +rde_dispatch_imsg(int fd, short event, void *bula) +{ + struct imsgbuf *ibuf = bula; + struct rip_route rr; + struct imsg imsg; + int n; + + switch (event) { + case EV_READ: + if ((n = imsg_read(ibuf)) == -1) + fatal("imsg_read error"); + if (n == 0) /* connection closed */ + fatalx("pipe closed"); + break; + case EV_WRITE: + if (msgbuf_write(&ibuf->w) == -1) + fatal("msgbuf_write"); + imsg_event_add(ibuf); + return; + default: + fatalx("unknown event"); + } + + for (;;) { + if ((n = imsg_get(ibuf, &imsg)) == -1) + fatal("rde_dispatch_imsg: imsg_read error"); + if (n == 0) + break; + + switch (imsg.hdr.type) { + case IMSG_ROUTE_FEED: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(rr)) + fatalx("invalid size of RDE request"); + + memcpy(&rr, imsg.data, sizeof(rr)); + + if (rde_check_route(&rr) == -1) + log_debug("rde_dispatch_imsg: " + "packet malformed\n"); + break; + case IMSG_FULL_REQUEST: + bzero(&rr, sizeof(rr)); + /* AFI == 0 && metric == INFINITY request the + whole routing table + */ + rr.metric = INFINITY; + rde_imsg_compose_ripe(IMSG_REQUEST_ADD, 0, + 0, &rr, sizeof(rr)); + rde_imsg_compose_ripe(IMSG_SEND_REQUEST, 0, + 0, NULL, 0); + break; + case IMSG_FULL_RESPONSE: + rt_snap(imsg.hdr.peerid); + rde_imsg_compose_ripe(IMSG_SEND_RESPONSE, + imsg.hdr.peerid, 0, NULL, 0); + break; + case IMSG_ROUTE_REQUEST: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(rr)) + fatalx("invalid size of RDE request"); + + memcpy(&rr, imsg.data, sizeof(rr)); + + rt_complete(&rr); + rde_imsg_compose_ripe(IMSG_RESPONSE_ADD, + imsg.hdr.peerid, 0, &rr, sizeof(rr)); + + break; + case IMSG_ROUTE_REQUEST_END: + rde_imsg_compose_ripe(IMSG_SEND_RESPONSE, + imsg.hdr.peerid, 0, NULL, 0); + break; + case IMSG_CTL_SHOW_RIB: + rt_dump(imsg.hdr.pid); + + imsg_compose(ibuf_ripe, IMSG_CTL_END, 0, imsg.hdr.pid, + NULL, 0); + + break; + default: + log_debug("rde_dispatch_msg: unexpected imsg %d", + imsg.hdr.type); + break; + } + imsg_free(&imsg); + } + imsg_event_add(ibuf); +} + +/* ARGSUSED */ +void +rde_dispatch_parent(int fd, short event, void *bula) +{ + struct imsg imsg; + struct rt_node *rt; + struct kroute kr; + struct imsgbuf *ibuf = bula; + ssize_t n; + + switch (event) { + case EV_READ: + if ((n = imsg_read(ibuf)) == -1) + fatal("imsg_read error"); + if (n == 0) /* connection closed */ + fatalx("pipe closed"); + break; + case EV_WRITE: + if (msgbuf_write(&ibuf->w) == -1) + fatal("msgbuf_write"); + imsg_event_add(ibuf); + return; + default: + fatalx("unknown event"); + } + + for (;;) { + if ((n = imsg_get(ibuf, &imsg)) == -1) + fatal("rde_dispatch_parent: imsg_read error"); + if (n == 0) + break; + + switch (imsg.hdr.type) { + case IMSG_NETWORK_ADD: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(kr)) { + log_warnx("rde_dispatch: wrong imsg len"); + break; + } + + memcpy(&kr, imsg.data, sizeof(kr)); + + rt = rt_new_kr(&kr); + rt_insert(rt); + break; + case IMSG_NETWORK_DEL: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(kr)) { + log_warnx("rde_dispatch: wrong imsg len"); + break; + } + memcpy(&kr, imsg.data, sizeof(kr)); + + if ((rt = rt_find(kr.prefix.s_addr, + kr.netmask.s_addr)) != NULL) + rt_remove(rt); + break; + case IMSG_KROUTE_GET: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(kr)) { + log_warnx("rde_dispatch: wrong imsg len"); + break; + } + memcpy(&kr, imsg.data, sizeof(kr)); + + if ((rt = rt_find(kr.prefix.s_addr, + kr.netmask.s_addr)) != NULL) + rde_send_change_kroute(rt); + else + /* should not happen */ + imsg_compose(ibuf_main, IMSG_KROUTE_DELETE, 0, + 0, &kr, sizeof(kr)); + + break; + default: + log_debug("rde_dispatch_parent: unexpected imsg %d", + imsg.hdr.type); + break; + } + imsg_free(&imsg); + } + imsg_event_add(ibuf); +} + +void +rde_send_change_kroute(struct rt_node *r) +{ + struct kroute kr; + + bzero(&kr, sizeof(kr)); + kr.prefix.s_addr = r->prefix.s_addr; + kr.nexthop.s_addr = r->nexthop.s_addr; + kr.netmask.s_addr = r->netmask.s_addr; + kr.metric = r->metric; + kr.flags = r->flags; + kr.ifindex = r->ifindex; + + imsg_compose(ibuf_main, IMSG_KROUTE_CHANGE, 0, 0, &kr, sizeof(kr)); +} + +void +rde_send_delete_kroute(struct rt_node *r) +{ + struct kroute kr; + + bzero(&kr, sizeof(kr)); + kr.prefix.s_addr = r->prefix.s_addr; + kr.nexthop.s_addr = r->nexthop.s_addr; + kr.netmask.s_addr = r->netmask.s_addr; + kr.metric = r->metric; + kr.flags = r->flags; + kr.ifindex = r->ifindex; + + imsg_compose(ibuf_main, IMSG_KROUTE_DELETE, 0, 0, &kr, sizeof(kr)); +} + +int +rde_check_route(struct rip_route *e) +{ + struct rt_node *rn; + struct iface *iface; + int metric; + + if ((e->nexthop.s_addr & htonl(IN_CLASSA_NET)) == + htonl(INADDR_LOOPBACK & IN_CLASSA_NET) || + (e->nexthop.s_addr == INADDR_ANY)) + return (-1); + + if ((e->address.s_addr & htonl(IN_CLASSA_NET)) == + htonl(INADDR_LOOPBACK & IN_CLASSA_NET)) + return (-1); + + if (e->metric > INFINITY) + return (-1); + + if ((iface = if_find_index(e->ifindex)) == NULL) + return (-1); + + metric = MIN(INFINITY, e->metric + iface->cost); + if (metric >= INFINITY) + return (0); + + if ((rn = rt_find(e->address.s_addr, e->mask.s_addr)) == NULL) { + rn = rt_new_rr(e, metric); + rt_insert(rn); + rde_send_change_kroute(rn); + route_start_timeout(rn); + triggered_update(rn); + } else { + /* + * XXX don't we have to track all incomming routes? + * what happens if the kernel route is removed later. + */ + if (rn->flags & F_KERNEL) + return (0); + + if (metric < rn->metric) { + rn->metric = metric; + rn->nexthop.s_addr = e->nexthop.s_addr; + rn->ifindex = e->ifindex; + rde_send_change_kroute(rn); + triggered_update(rn); + } else if (e->nexthop.s_addr == rn->nexthop.s_addr && + e->metric > metric) { + rn->metric = metric; + rde_send_change_kroute(rn); + triggered_update(rn); + } + + if (e->nexthop.s_addr == rn->nexthop.s_addr) + route_reset_timers(rn); + } + + return (0); +} + +void +triggered_update(struct rt_node *rn) +{ + struct rip_route rr; + + rr.address.s_addr = rn->prefix.s_addr; + rr.mask.s_addr = rn->netmask.s_addr; + rr.nexthop.s_addr = rn->nexthop.s_addr; + rr.metric = rn->metric; + rr.ifindex = rn->ifindex; + + rde_imsg_compose_ripe(IMSG_SEND_TRIGGERED_UPDATE, 0, 0, &rr, + sizeof(struct rip_route)); +} diff --git a/usr.sbin/ripd/rde.h b/usr.sbin/ripd/rde.h new file mode 100644 index 00000000000..f27d561a8ae --- /dev/null +++ b/usr.sbin/ripd/rde.h @@ -0,0 +1,64 @@ +/* $OpenBSD: rde.h,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _RDE_H_ +#define _RDE_H_ + +#include <sys/types.h> +#include <sys/time.h> +#include <sys/tree.h> +#include <sys/queue.h> +#include <event.h> +#include <limits.h> + +struct rt_node { + RB_ENTRY(rt_node) entry; + struct event timeout_timer; + struct event garbage_timer; + struct in_addr prefix; + struct in_addr netmask; + struct in_addr nexthop; + u_short ifindex; + u_int16_t flags; + u_int8_t metric; +}; + +/* rde.c */ +pid_t rde(struct ripd_conf *, int [2], int [2], int [2]); +void rde_send_change_kroute(struct rt_node *); +void rde_send_delete_kroute(struct rt_node *); +int rde_imsg_compose_ripe(int, u_int32_t, pid_t, void *, + u_int16_t); + +/* rde_routes.c */ +void rt_init(void); +int rt_compare(struct rt_node *, struct rt_node *); +struct rt_node *rt_find(in_addr_t, in_addr_t); +struct rt_node *rt_new_kr(struct kroute *); +struct rt_node *rt_new_rr(struct rip_route *, int); +int rt_insert(struct rt_node *); +int rt_remove(struct rt_node *); +void rt_complete(struct rip_route *); +void rt_snap(u_int32_t); +void rt_clear(void); +void route_reset_timers(struct rt_node *); +int route_start_timeout(struct rt_node *); +void rt_dump(pid_t); + +#endif /* _RDE_H_ */ diff --git a/usr.sbin/ripd/rde_rib.c b/usr.sbin/ripd/rde_rib.c new file mode 100644 index 00000000000..e26292ee953 --- /dev/null +++ b/usr.sbin/ripd/rde_rib.c @@ -0,0 +1,258 @@ +/* $OpenBSD: rde_rib.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <net/if.h> +#include <net/if_types.h> +#include <ctype.h> +#include <err.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <event.h> + +#include "ripd.h" +#include "rip.h" +#include "log.h" +#include "rde.h" + +extern struct ripd_conf *rdeconf; +RB_HEAD(rt_tree, rt_node) rt; +RB_PROTOTYPE(rt_tree, rt_node, entry, rt_compare) +RB_GENERATE(rt_tree, rt_node, entry, rt_compare) + +void route_action_timeout(int, short, void *); +void route_action_garbage(int, short, void *); +int route_start_timeout(struct rt_node *); + +/* timers */ +int +route_start_timeout(struct rt_node *rn) +{ + struct timeval tv; + + timerclear(&tv); + tv.tv_sec = ROUTE_TIMEOUT; + + return (evtimer_add(&rn->timeout_timer, &tv)); +} + +/* ARGSUSED */ +void +route_action_timeout(int fd, short event, void *arg) +{ + struct rt_node *r = arg; + struct timeval tv; + + timerclear(&tv); + r->metric = INFINITY; + tv.tv_sec = ROUTE_GARBAGE; + + if (evtimer_add(&r->garbage_timer, &tv) == -1) + fatal("route_action_timeout"); + + rde_send_change_kroute(r); +} + +/* ARGSUSED */ +void +route_action_garbage(int fd, short event, void *arg) +{ + struct rt_node *r = arg; + + rde_send_delete_kroute(r); + rt_remove(r); +} + +void +route_reset_timers(struct rt_node *r) +{ + struct timeval tv; + + timerclear(&tv); + tv.tv_sec = ROUTE_TIMEOUT; + evtimer_del(&r->timeout_timer); + evtimer_del(&r->garbage_timer); + + event_add(&r->timeout_timer, &tv); +} + +/* route table */ +void +rt_init(void) +{ + RB_INIT(&rt); +} + +int +rt_compare(struct rt_node *a, struct rt_node *b) +{ + if (ntohl(a->prefix.s_addr) < ntohl(b->prefix.s_addr)) + return (-1); + if (ntohl(a->prefix.s_addr) > ntohl(b->prefix.s_addr)) + return (1); + if (ntohl(a->netmask.s_addr) < ntohl(b->netmask.s_addr)) + return (-1); + if (ntohl(a->netmask.s_addr) > ntohl(b->netmask.s_addr)) + return (1); + + return (0); +} + +struct rt_node * +rt_find(in_addr_t prefix, in_addr_t netmask) +{ + struct rt_node s; + + s.prefix.s_addr = prefix; + s.netmask.s_addr = netmask; + + return (RB_FIND(rt_tree, &rt, &s)); +} + +struct rt_node * +rt_new_kr(struct kroute *kr) +{ + struct rt_node *rn; + + if ((rn = calloc(1, sizeof(*rn))) == NULL) + fatal("rt_new_kr"); + + evtimer_set(&rn->timeout_timer, route_action_timeout, rn); + evtimer_set(&rn->garbage_timer, route_action_garbage, rn); + + rn->prefix.s_addr = kr->prefix.s_addr; + rn->netmask.s_addr = kr->netmask.s_addr; + rn->nexthop.s_addr = kr->nexthop.s_addr; + rn->metric = kr->metric; + rn->ifindex = kr->ifindex; + rn->flags = F_KERNEL; + + return (rn); +} + +struct rt_node * +rt_new_rr(struct rip_route *e, int metric) +{ + struct rt_node *rn; + + if ((rn = calloc(1, sizeof(*rn))) == NULL) + fatal("rt_new_rr"); + + evtimer_set(&rn->timeout_timer, route_action_timeout, rn); + evtimer_set(&rn->garbage_timer, route_action_garbage, rn); + + rn->prefix.s_addr = e->address.s_addr; + rn->netmask.s_addr = e->mask.s_addr; + rn->nexthop.s_addr = e->nexthop.s_addr; + rn->metric = metric; + rn->ifindex = e->ifindex; + rn->flags = F_RIPD_INSERTED; + + return (rn); +} + +int +rt_insert(struct rt_node *r) +{ + if (RB_INSERT(rt_tree, &rt, r) != NULL) { + log_warnx("rt_insert failed for %s/%s", + inet_ntoa(r->prefix), inet_ntoa(r->netmask)); + free(r); + return (-1); + } + + return (0); +} + +int +rt_remove(struct rt_node *r) +{ + if (RB_REMOVE(rt_tree, &rt, r) == NULL) { + log_warnx("rt_remove failed for %s/%s", + inet_ntoa(r->prefix), inet_ntoa(r->netmask)); + return (-1); + } + + free(r); + return (0); +} + +void +rt_snap(u_int32_t peerid) +{ + struct rt_node *r; + struct rip_route rr; + + bzero(&rr, sizeof(rr)); + + RB_FOREACH(r, rt_tree, &rt) { + rr.address = r->prefix; + rr.mask = r->netmask; + rr.nexthop = r->nexthop; + rr.metric = r->metric; + rr.ifindex = r->ifindex; + + rde_imsg_compose_ripe(IMSG_RESPONSE_ADD, peerid, 0, &rr, + sizeof(rr)); + } +} + +void +rt_dump(pid_t pid) +{ + struct rt_node *r; + static struct ctl_rt rtctl; + + RB_FOREACH(r, rt_tree, &rt) { + rtctl.prefix.s_addr = r->prefix.s_addr; + rtctl.netmask.s_addr = r->netmask.s_addr; + rtctl.nexthop.s_addr = r->nexthop.s_addr; + rtctl.metric = r->metric; + rtctl.flags = r->flags; + + rde_imsg_compose_ripe(IMSG_CTL_SHOW_RIB, 0, pid, &rtctl, + sizeof(rtctl)); + } +} + +void +rt_complete(struct rip_route *rr) +{ + struct rt_node *rn; + + if ((rn = rt_find(rr->address.s_addr, rr->mask.s_addr)) == NULL) + rr->metric = INFINITY; + else + rr->metric = rn->metric; +} + +void +rt_clear(void) +{ + struct rt_node *r; + + while ((r = RB_MIN(rt_tree, &rt)) != NULL) + rt_remove(r); +} diff --git a/usr.sbin/ripd/rip.h b/usr.sbin/ripd/rip.h new file mode 100644 index 00000000000..a1b2a3c3d91 --- /dev/null +++ b/usr.sbin/ripd/rip.h @@ -0,0 +1,82 @@ +/* $OpenBSD: rip.h,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* RIP protocol definitions */ + +#ifndef _RIP_H_ +#define _RIP_H_ + +/* misc */ +#define RIP_VERSION 2 +#define ALL_RIP_ROUTERS "224.0.0.9" +#define RIP_PORT 520 + +#define MIN_MD_ID 0 +#define MAX_MD_ID 255 + +/* metric */ +#define INFINITY 16 + +/* timers */ +#define KEEPALIVE 30 +#define OFFSET 10 + +#define MAX_RIP_ENTRIES 25 + +/* RIP command */ +#define COMMAND_REQUEST 1 +#define COMMAND_RESPONSE 2 + +#define RIP_HDR_LEN sizeof(struct rip_hdr) +#define RIP_ENTRY_LEN sizeof(struct rip_entry) + +struct rip_hdr { + u_int8_t command; + u_int8_t version; + u_int16_t dummy; +}; + +struct rip_entry { + u_int16_t AFI; + u_int16_t route_tag; + u_int32_t address; + u_int32_t mask; + u_int32_t nexthop; + u_int32_t metric; +}; + +/* auth */ +#define AUTH 0xFFFF +#define AUTH_TRLR_HDR_LEN 4 + +/* auth general struct */ +struct rip_auth { + u_int16_t auth_fixed; + u_int16_t auth_type; +}; + +/* Keyed MD5 auth struct */ +struct md5_auth { + u_int16_t auth_offset; + u_int8_t auth_keyid; + u_int8_t auth_length; + u_int32_t auth_seq; + u_int64_t auth_reserved; +}; + +#endif /* _RIP_H_ */ diff --git a/usr.sbin/ripd/ripd.8 b/usr.sbin/ripd/ripd.8 new file mode 100644 index 00000000000..42092db8d0d --- /dev/null +++ b/usr.sbin/ripd/ripd.8 @@ -0,0 +1,81 @@ +.\" $OpenBSD: ripd.8,v 1.1 2006/10/18 16:11:58 norby Exp $ +.\" +.\" Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> +.\" Copyright (c) 2004, 2005, 2006 Esben Norby <norby@openbsd.org> +.\" +.\" Permission to use, copy, modify, and distribute this software for any +.\" purpose with or without fee is hereby granted, provided that the above +.\" copyright notice and this permission notice appear in all copies. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +.\" +.Dd February 27, 2006 +.Dt RIPD 8 +.Os +.Sh NAME +.Nm ripd +.Nd "Routing Information Protocol daemon" +.Sh SYNOPSIS +.Nm +.Op Fl dnv +.Op Fl f Ar file +.Sh DESCRIPTION +.Nm +is the Routing Information Protocol +.Pq RIP +daemon which manages routers' routing tables. +For RIPD to work, +multicast routing must be enabled by setting multicast_router=YES in +.Pa /etc/rc.conf.local . +.Pp +The options are as follows: +.Bl -tag -width Ds +.It Fl d +Do not daemonize. +If this option is specified, +.Nm +will run in the foreground and log to +.Em stderr . +.It Fl f Ar file +Specify an alternative configuration file. +.It Fl n +Configtest mode. +Only check the configuration file for validity. +.It Fl v +Produce more verbose output. +.El +.Sh FILES +.Bl -tag -width "/var/run/ripd.sockXX" -compact +.It /etc/ripd.conf +Default +.Nm +configuration file. +.It /var/run/ripd.sock +Unix-domain socket used for communication with +.Xr ripctl 8 . +.El +.Sh SEE ALSO +.Xr ripd.conf 5 , +.Xr rc.conf 8 , +.Xr ripctl 8 +.Rs +.%R RFC 2453 +.%T RIP Version 2 +.%D November 1998 +.Re +.Rs +.%R RFC 2082 +.%T "RIP-2 MD5 Authentication" +.%D January 1997 +.Re +.Sh HISTORY +The +.Nm +program first appeared in +.Ox 4.0 . diff --git a/usr.sbin/ripd/ripd.conf.5 b/usr.sbin/ripd/ripd.conf.5 new file mode 100644 index 00000000000..7a93b144bf8 --- /dev/null +++ b/usr.sbin/ripd/ripd.conf.5 @@ -0,0 +1,195 @@ +.\" $OpenBSD: ripd.conf.5,v 1.1 2006/10/18 16:11:58 norby Exp $ +.\" +.\" Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> +.\" Copyright (c) 2005, 2006 Esben Norby <norby@openbsd.org> +.\" Copyright (c) 2004 Claudio Jeker <claudio@openbsd.org> +.\" Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> +.\" Copyright (c) 2002 Daniel Hartmeier <dhartmei@openbsd.org> +.\" +.\" Permission to use, copy, modify, and distribute this software for any +.\" purpose with or without fee is hereby granted, provided that the above +.\" copyright notice and this permission notice appear in all copies. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +.\" +.Dd February 27, 2006 +.Dt RIPD.CONF 5 +.Os +.Sh NAME +.Nm ripd.conf +.Nd Routing Information Protocol daemon configuration file +.Sh DESCRIPTION +The +.Xr ripd 8 +daemon implements the Routing Information Protocol version 2 as described +in rfc 2453. +.Sh SECTIONS +The +.Nm +config file is divided into three main sections. +.Bl -tag -width xxxx +.It Sy Macros +User-defined variables may be defined and used later, simplifying the +configuration file. +.It Sy Global Configuration +Global settings for +.Xr ripd 8 . +.It Sy Interfaces Configuration +Interface specific parameters. +.El +.Sh MACROS +Much like +.Xr cpp 1 +or +.Xr m4 1 , +macros can be defined that will later be expanded in context. +Macro names must start with a letter, and may contain letters, digits, +and underscores. +Macro names may not be reserved words (for example, +.Ic cost ) . +Macros are not expanded inside quotes. +.Pp +For example: +.Bd -literal -offset indent +hi="2" +interface em0 { + cost $hi +} +.Ed +.Sh GLOBAL CONFIGURATION +Global settings concerns the main behaviour of the daemon. +.Bl -tag -width Ds +.It Xo +.Ic fib-update +.Pq Ic yes Ns \&| Ns Ic no +.Xc +If set to +.Ic no , +do not update the Forwarding Information Base, a.k.a. the kernel routing +table. +The default is +.Ic yes . +.Pp +.It Xo +.Ic redistribute +.Sm off +.Po Ic static Ns \&| Ns Ic connected Ns \&| Ns +.Ic default Ns \&| +.Ic none Pc +.Sm on +.Xc +If set to +.Ic connected , +routes to directly attached networks will be +announced over RIP. +If set to +.Ic static , +static routes will be announced over RIP. +If set to +.Ic default , +a default route pointing to this router will be announced over RIP. +By default no additional routes will be announced over RIP. +.Pp +.It Xo +.Ic split-horizon +.Sm off +.Po Ic default Ns \&| Ns Ic poisoned Ns \&| Ns +.Ic none Pc +.Sm on +.Xc +If set to +.Ic default , +do not redistribute routes to the interface from which they were learned. +If set to +.Ic poisoned , +redistribute routes to the interface from which they were learned, but +forcing the metric to infinity. +Both these behaviours can resolve routing loops when a router goes down. +The default is +.Ic none . +.Pp +.It Xo +.Ic triggered-updates +.Pq Ic yes Ns \&| Ns Ic no +.Xc +Immediately trigger responses when a route changes. +The default is +.Ic yes . +.El +.Sh INTERFACES +Each interface can have several parameters configured individually, otherwise +they are inherited. +.Bd -literal -offset indent +interface em0 { +} +.Ed +.Pp +Interface specific parameters are listed below. +.Bl -tag -width Ds +.It Ic auth-key Ar key +Set the authentication key for +.Ic simple +authentication. +Up to 16 characters can be specified. +.It Ic auth-md Ar key-id key +Set the authentication +.Ar key-id +and +.Ar key +for +.Ic crypt +authentication. +The valid range for +.Ar key-id +is 0\-255. +Up to 16 characters can be specified for +.Ar key . +Multiple keys may be specified. +.It Ic auth-md-keyid Ar key-id +Configure the +.Ar key-id +to use for +.Ic crypt +authentication. +The valid range for +.Ar key-id +is 0\-255. +The default key-id is 1. +.It Xo +.Ic auth-type +.Po Ic none Ns \&| Ns +.Ic simple Ns \&| Ns Ic crypt Pc +.Xc +Set the authentication type. +The default is +.Ic none . +Simple authentication uses a plaintext password, up to 16 characters. +Crypt authentication uses an MD5 hash. +.It Ic cost Ar number +Cost of the network connected through this interface. +Values must be between 1 and 16, inclusive. +.It Ic passive +Prevent transmission and reception of RIP packets on this interface. +.El +.Sh FILES +.Bl -tag -width "/etc/ripd.conf" -compact +.It Pa /etc/ripd.conf +.Xr ripd 8 +configuration file +.El +.Sh SEE ALSO +.Xr rc.conf.local 8 , +.Xr ripctl 8 , +.Xr ripd 8 +.Rs +.Sh HISTORY +The +.Nm +file format first appeared in +.Ox 4.0 . diff --git a/usr.sbin/ripd/ripd.h b/usr.sbin/ripd/ripd.h new file mode 100644 index 00000000000..12f143437e2 --- /dev/null +++ b/usr.sbin/ripd/ripd.h @@ -0,0 +1,392 @@ +/* $OpenBSD: ripd.h,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2004 Esben Norby <norby@openbsd.org> + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _RIPD_H_ +#define _RIPD_H_ + +#include <sys/queue.h> +#include <sys/socket.h> +#include <sys/tree.h> +#include <md5.h> +#include <net/if.h> +#include <netinet/in.h> +#include <event.h> + +#define CONF_FILE "/etc/ripd.conf" +#define RIPD_SOCKET "/var/run/ripd.sock" +#define RIPD_USER "_ripd" +#define READ_BUF_SIZE 65535 + +#define NBR_HASHSIZE 128 +#define NBR_IDSELF 1 +#define NBR_CNTSTART (NBR_IDSELF + 1) + +#define ROUTE_TIMEOUT 180 +#define ROUTE_GARBAGE 120 + +#define NBR_TIMEOUT 180 + +#define READ_BUF_SIZE 65535 +#define RT_BUF_SIZE 16384 +#define MAX_RTSOCK_BUF 128 * 1024 + +#define RIPD_FLAG_NO_FIB_UPDATE 0x0001 + +#define F_RIPD_INSERTED 0x0001 +#define F_KERNEL 0x0002 +#define F_BGPD_INSERTED 0x0004 +#define F_CONNECTED 0x0008 +#define F_DOWN 0x0010 +#define F_STATIC 0x0020 +#define F_DYNAMIC 0x0040 +#define F_OSPFD_INSERTED 0x0080 +#define F_REDISTRIBUTED 0x0100 + +#define REDISTRIBUTE_NONE 0x0 +#define REDISTRIBUTE_STATIC 0x01 +#define REDISTRIBUTE_CONNECTED 0x02 +#define REDISTRIBUTE_DEFAULT 0x04 + +#define OPT_SPLIT_HORIZON 0x01 +#define OPT_SPLIT_POISONED 0x02 +#define OPT_TRIGGERED_UPDATES 0x04 + +/* buffer */ +struct buf { + TAILQ_ENTRY(buf) entry; + u_char *buf; + size_t size; + size_t max; + size_t wpos; + size_t rpos; +}; + +struct msgbuf { + TAILQ_HEAD(, buf) bufs; + u_int32_t queued; + int fd; +}; + +#define IMSG_HEADER_SIZE sizeof(struct imsg_hdr) +#define MAX_IMSGSIZE 8192 + +struct buf_read { + u_char buf[READ_BUF_SIZE]; + u_char *rptr; + size_t wpos; +}; + +struct imsgbuf { + TAILQ_HEAD(, imsg_fd) fds; + struct buf_read r; + struct msgbuf w; + struct event ev; + void (*handler)(int, short, void *); + int fd; + pid_t pid; + short events; +}; + +enum imsg_type { + IMSG_NONE, + IMSG_CTL_END, + IMSG_CTL_RELOAD, + IMSG_CTL_IFINFO, + IMSG_IFINFO, + IMSG_CTL_FIB_COUPLE, + IMSG_CTL_FIB_DECOUPLE, + IMSG_CTL_KROUTE, + IMSG_CTL_KROUTE_ADDR, + IMSG_CTL_SHOW_INTERFACE, + IMSG_CTL_SHOW_IFACE, + IMSG_CTL_SHOW_NBR, + IMSG_CTL_SHOW_RIB, + IMSG_KROUTE_CHANGE, + IMSG_KROUTE_DELETE, + IMSG_KROUTE_GET, + IMSG_NETWORK_ADD, + IMSG_NETWORK_DEL, + IMSG_ROUTE_FEED, + IMSG_RESPONSE_ADD, + IMSG_SEND_RESPONSE, + IMSG_FULL_RESPONSE, + IMSG_ROUTE_REQUEST, + IMSG_ROUTE_REQUEST_END, + IMSG_FULL_REQUEST, + IMSG_REQUEST_ADD, + IMSG_SEND_REQUEST, + IMSG_SEND_TRIGGERED_UPDATE +}; + +struct imsg_hdr { + enum imsg_type type; + u_int16_t len; + u_int32_t peerid; + pid_t pid; +}; + +struct imsg { + struct imsg_hdr hdr; + void *data; +}; + +struct imsg_fd { + TAILQ_ENTRY(imsg_fd) entry; + int fd; +}; + +/* interface states */ +#define IF_STA_DOWN 0x01 +#define IF_STA_ACTIVE (~IF_STA_DOWN) +#define IF_STA_ANY 0x7f + +/* interface events */ +enum iface_event { + IF_EVT_NOTHING, + IF_EVT_UP, + IF_EVT_DOWN +}; + +/* interface actions */ +enum iface_action { + IF_ACT_NOTHING, + IF_ACT_STRT, + IF_ACT_RST +}; + +/* interface types */ +enum iface_type { + IF_TYPE_POINTOPOINT, + IF_TYPE_BROADCAST, + IF_TYPE_NBMA, + IF_TYPE_POINTOMULTIPOINT +}; + +/* neighbor states */ +#define NBR_STA_DOWN 0x01 +#define NBR_STA_ACTIVE (~NBR_STA_DOWN) +#define NBR_STA_ANY 0xff + +struct auth_md { + TAILQ_ENTRY(auth_md) entry; + char key[MD5_DIGEST_LENGTH]; + u_int8_t keyid; +}; + +#define MAX_SIMPLE_AUTH_LEN 16 + +/* auth types */ +enum auth_type { + AUTH_NONE = 1, + AUTH_SIMPLE, + AUTH_CRYPT +}; + +TAILQ_HEAD(auth_md_head, auth_md); +TAILQ_HEAD(packet_head, packet_entry); + +struct iface { + LIST_ENTRY(iface) entry; + LIST_HEAD(, nbr) nbr_list; + LIST_HEAD(, nbr_failed) failed_nbr_list; + char name[IF_NAMESIZE]; + char auth_key[MAX_SIMPLE_AUTH_LEN]; + struct in_addr addr; + struct in_addr dst; + struct in_addr mask; + struct packet_head rq_list; + struct packet_head rp_list; + struct auth_md_head auth_md_list; + + time_t uptime; + u_long mtu; + u_long baudrate; + int fd; /* XXX */ + int state; + u_short ifindex; + u_int16_t cost; + u_int16_t flags; + enum iface_type type; + enum auth_type auth_type; + u_int8_t linktype; + u_int8_t media_type; + u_int8_t passive; + u_int8_t linkstate; + u_int8_t auth_keyid; +}; + +struct rip_route { + struct in_addr address; + struct in_addr mask; + struct in_addr nexthop; + int refcount; + u_short ifindex; + u_int8_t metric; +}; + +struct packet_entry { + TAILQ_ENTRY(packet_entry) entry; + struct rip_route *rr; +}; + +enum { + PROC_MAIN, + PROC_RIP_ENGINE, + PROC_RDE_ENGINE +} ripd_process; + +struct ripd_conf { + struct event ev; + struct event report_timer; + LIST_HEAD(, iface) iface_list; + u_int32_t opts; +#define RIPD_OPT_VERBOSE 0x00000001 +#define RIPD_OPT_VERBOSE2 0x00000002 +#define RIPD_OPT_NOACTION 0x00000004 + int flags; + int redistribute_flags; + int options; + int rip_socket; +}; + +/* kroute */ +struct kroute { + struct in_addr prefix; + struct in_addr netmask; + struct in_addr nexthop; + u_int8_t metric; + u_int16_t flags; + u_short ifindex; +}; + +struct kif { + char ifname[IF_NAMESIZE]; + u_long baudrate; + int flags; + int mtu; + u_short ifindex; + u_int8_t media_type; + u_int8_t link_state; + u_int8_t nh_reachable; /* for nexthop verification */ +}; + +/* control data structures */ +struct ctl_iface { + char name[IF_NAMESIZE]; + struct in_addr addr; + struct in_addr mask; + + time_t uptime; + time_t report_timer; + + u_int32_t baudrate; + + unsigned int ifindex; + int state; + int mtu; + + u_int16_t flags; + u_int16_t metric; + enum iface_type type; + u_int8_t linkstate; + u_int8_t mediatype; + u_int8_t passive; +}; + +struct ctl_rt { + struct in_addr prefix; + struct in_addr netmask; + struct in_addr nexthop; + time_t uptime; + time_t expire; + u_int32_t metric; + u_int8_t flags; +}; + +struct ctl_nbr { + char name[IF_NAMESIZE]; + struct in_addr id; + struct in_addr addr; + time_t dead_timer; + time_t uptime; + int nbr_state; + int iface_state; +}; + +int kif_init(void); +int kr_init(int); +int kr_change(struct kroute *); +int kr_delete(struct kroute *); +void kr_shutdown(void); +void kr_fib_couple(void); +void kr_fib_decouple(void); +void kr_dispatch_msg(int, short, void *); +void kr_show_route(struct imsg *); +void kr_ifinfo(char *, pid_t); +struct kif *kif_findname(char *); + +in_addr_t prefixlen2mask(u_int8_t); +u_int8_t mask2prefixlen(in_addr_t); + +/* ripd.c */ +void main_imsg_compose_ripe(int, pid_t, void *, u_int16_t); +void main_imsg_compose_rde(int, pid_t, void *, u_int16_t); +int rip_redistribute(struct kroute *); + +/* parse.y */ +struct ripd_conf *parse_config(char *, int); +int cmdline_symset(char *); + +/* buffer.c */ +struct buf *buf_open(size_t); +struct buf *buf_dynamic(size_t, size_t); +int buf_add(struct buf *, void *, size_t); +void *buf_reserve(struct buf *, size_t); +void *buf_seek(struct buf *, size_t, size_t); +int buf_close(struct msgbuf *, struct buf *); +void buf_free(struct buf *); +void msgbuf_init(struct msgbuf *); +void msgbuf_clear(struct msgbuf *); +int msgbuf_write(struct msgbuf *); + +/* imsg.c */ +void imsg_init(struct imsgbuf *, int, void (*)(int, short, void *)); +ssize_t imsg_read(struct imsgbuf *); +ssize_t imsg_get(struct imsgbuf *, struct imsg *); +int imsg_compose(struct imsgbuf *, enum imsg_type, u_int32_t, + pid_t, void *, u_int16_t); +struct buf *imsg_create(struct imsgbuf *, enum imsg_type, u_int32_t, pid_t, + u_int16_t); +int imsg_add(struct buf *, void *, u_int16_t); +int imsg_close(struct imsgbuf *, struct buf *); +void imsg_free(struct imsg *); +void imsg_event_add(struct imsgbuf *); + +/* printconf.c */ +void print_config(struct ripd_conf *); + +/* log.c */ +const char *if_state_name(int); +const char *if_auth_name(enum auth_type); +const char *nbr_state_name(int); + +/* interface.c */ +struct iface *if_find_index(u_short); + +#endif /* _RIPD_H_ */ diff --git a/usr.sbin/ripd/ripe.c b/usr.sbin/ripd/ripe.c new file mode 100644 index 00000000000..3f651bb5411 --- /dev/null +++ b/usr.sbin/ripd/ripe.c @@ -0,0 +1,504 @@ +/* $OpenBSD: ripe.c,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org> + * Copyright (c) 2004 Esben Norby <norby@openbsd.org> + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/queue.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <net/if_types.h> +#include <stdlib.h> +#include <signal.h> +#include <string.h> +#include <fcntl.h> +#include <pwd.h> +#include <unistd.h> +#include <event.h> +#include <err.h> +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> + +#include "ripd.h" +#include "rip.h" +#include "ripe.h" +#include "log.h" +#include "control.h" + +void ripe_sig_handler(int, short, void *); +void ripe_shutdown(void); + +struct ripd_conf *oeconf = NULL; +struct imsgbuf *ibuf_main; +struct imsgbuf *ibuf_rde; + +/* ARGSUSED */ +void +ripe_sig_handler(int sig, short event, void *bula) +{ + switch (sig) { + case SIGINT: + case SIGTERM: + ripe_shutdown(); + /* NOTREACHED */ + default: + fatalx("unexpected signal"); + } +} + +/* rip engine */ +pid_t +ripe(struct ripd_conf *xconf, int pipe_parent2ripe[2], int pipe_ripe2rde[2], + int pipe_parent2rde[2]) +{ + struct iface *iface = NULL; + struct sockaddr_in addr; + struct passwd *pw; + struct event ev_sigint, ev_sigterm; + pid_t pid; + + switch (pid = fork()) { + case -1: + fatal("cannot fork"); + case 0: + break; + default: + return (pid); + } + + /* create ripd control socket outside chroot */ + if (control_init() == -1) + fatalx("control socket setup failed"); + + addr.sin_family = AF_INET; + addr.sin_port = htons(RIP_PORT); + addr.sin_addr.s_addr = INADDR_ANY; + + if ((xconf->rip_socket = socket(AF_INET, SOCK_DGRAM, + IPPROTO_UDP)) == -1) + fatalx("if_init: cannot create socket"); + + if (bind(xconf->rip_socket, (struct sockaddr *)&addr, + sizeof(addr)) == -1) + fatal("error creating socket"); + + /* set some defaults */ + if (if_set_opt(xconf->rip_socket) == -1) + fatal("if_set_opt"); + + if (if_set_mcast_ttl(xconf->rip_socket, IP_DEFAULT_MULTICAST_TTL) == -1) + fatal("if_set_mcast_ttl"); + + if (if_set_mcast_loop(xconf->rip_socket) == -1) + fatal("if_set_mcast_loop"); + + if (if_set_tos(xconf->rip_socket, IPTOS_PREC_INTERNETCONTROL) == -1) + fatal("if_set_tos"); + + if_set_recvbuf(xconf->rip_socket); + + oeconf = xconf; + + if ((pw = getpwnam(RIPD_USER)) == NULL) + fatal("getpwnam"); + + if (chroot(pw->pw_dir) == -1) + fatal("chroot"); + if (chdir("/") == -1) + fatal("chdir(\"/\")"); + + setproctitle("rip engine"); + ripd_process = PROC_RIP_ENGINE; + + if (setgroups(1, &pw->pw_gid) || + setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) || + setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid)) + fatal("can't drop privileges"); + + event_init(); + nbr_init(NBR_HASHSIZE); + + /* setup signal handler */ + signal_set(&ev_sigint, SIGINT, ripe_sig_handler, NULL); + signal_set(&ev_sigterm, SIGTERM, ripe_sig_handler, NULL); + signal_add(&ev_sigint, NULL); + signal_add(&ev_sigterm, NULL); + signal(SIGPIPE, SIG_IGN); + + /* setup pipes */ + close(pipe_parent2ripe[0]); + close(pipe_ripe2rde[1]); + close(pipe_parent2rde[0]); + close(pipe_parent2rde[1]); + + if ((ibuf_rde = malloc(sizeof(struct imsgbuf))) == NULL || + (ibuf_main = malloc(sizeof(struct imsgbuf))) == NULL) + fatal(NULL); + imsg_init(ibuf_rde, pipe_ripe2rde[0], ripe_dispatch_rde); + imsg_init(ibuf_main, pipe_parent2ripe[1], ripe_dispatch_main); + + /* setup event handler */ + ibuf_rde->events = EV_READ; + event_set(&ibuf_rde->ev, ibuf_rde->fd, ibuf_rde->events, + ibuf_rde->handler, ibuf_rde); + event_add(&ibuf_rde->ev, NULL); + + ibuf_main->events = EV_READ; + event_set(&ibuf_main->ev, ibuf_main->fd, ibuf_main->events, + ibuf_main->handler, ibuf_main); + event_add(&ibuf_main->ev, NULL); + + event_set(&oeconf->ev, oeconf->rip_socket, EV_READ|EV_PERSIST, + recv_packet, oeconf); + event_add(&oeconf->ev, NULL); + + /* listen on ripd control socket */ + TAILQ_INIT(&ctl_conns); + control_listen(); + + if ((pkt_ptr = calloc(1, READ_BUF_SIZE)) == NULL) + fatal("ripe"); + + /* start interfaces */ + LIST_FOREACH(iface, &xconf->iface_list, entry) { + if_init(xconf, iface); + if (if_fsm(iface, IF_EVT_UP)) + log_debug("error starting interface: %s", iface->name); + } + + evtimer_set(&oeconf->report_timer, report_timer, oeconf); + start_report_timer(); + + ripe_imsg_compose_rde(IMSG_FULL_REQUEST, 0, 0, NULL, 0); + + event_dispatch(); + + ripe_shutdown(); + /* NOTREACHED */ + return (0); +} + +/* imesg */ +int +ripe_imsg_compose_parent(int type, pid_t pid, void *data, u_int16_t datalen) +{ + return (imsg_compose(ibuf_main, type, 0, pid, data, datalen)); +} + +int +ripe_imsg_compose_rde(int type, u_int32_t peerid, pid_t pid, + void *data, u_int16_t datalen) +{ + return (imsg_compose(ibuf_rde, type, peerid, pid, data, datalen)); +} + +/* ARGSUSED */ +void +ripe_dispatch_main(int fd, short event, void *bula) +{ + struct imsg imsg; + struct imsgbuf *ibuf = bula; + int n, link_ok; + struct kif *kif; + struct iface *iface; + + switch (event) { + case EV_READ: + if ((n = imsg_read(ibuf)) == -1) + fatal("imsg_read error"); + if (n == 0) /* connection closed */ + fatalx("pipe closed"); + break; + case EV_WRITE: + if (msgbuf_write(&ibuf->w) == -1) + fatal("msgbuf_write"); + imsg_event_add(ibuf); + return; + default: + fatalx("unknown event"); + } + + for (;;) { + if ((n = imsg_get(ibuf, &imsg)) == -1) + fatal("ripe_dispatch_main: imsg_read error"); + if (n == 0) + break; + + switch (imsg.hdr.type) { + case IMSG_IFINFO: + if (imsg.hdr.len - IMSG_HEADER_SIZE != + sizeof(struct kif)) + fatalx("IFINFO imsg with wrong len"); + kif = imsg.data; + link_ok = (kif->flags & IFF_UP) && + (kif->link_state == LINK_STATE_UP || + (kif->link_state == LINK_STATE_UNKNOWN && + kif->media_type != IFT_CARP)); + + LIST_FOREACH(iface, &oeconf->iface_list, entry) { + if (kif->ifindex == iface->ifindex) { + iface->flags = kif->flags; + iface->linkstate = kif->link_state; + + if (link_ok) { + if_fsm(iface, IF_EVT_UP); + log_warnx("interface %s up", + iface->name); + } else { + if_fsm(iface, IF_EVT_DOWN); + log_warnx("interface %s down", + iface->name); + } + } + } + break; + case IMSG_CTL_IFINFO: + case IMSG_CTL_KROUTE: + case IMSG_CTL_KROUTE_ADDR: + case IMSG_CTL_END: + control_imsg_relay(&imsg); + break; + default: + log_debug("ripe_dispatch_main: error handling imsg %d", + imsg.hdr.type); + break; + } + imsg_free(&imsg); + } + imsg_event_add(ibuf); +} + +/* ARGSUSED */ +void +ripe_dispatch_rde(int fd, short event, void *bula) +{ + struct rip_route *rr; + struct imsg imsg; + struct imsgbuf *ibuf = bula; + struct iface *iface; + struct nbr *nbr; + int n; + + switch (event) { + case EV_READ: + if ((n = imsg_read(ibuf)) == -1) + fatal("imsg_read error"); + if (n == 0) /* connection closed */ + fatalx("pipe closed"); + break; + case EV_WRITE: + if (msgbuf_write(&ibuf->w) == -1) + fatal("msgbuf_write"); + imsg_event_add(ibuf); + return; + default: + fatalx("unknown event"); + } + + for (;;) { + if ((n = imsg_get(ibuf, &imsg)) == -1) + fatal("ripe_dispatch_rde: imsg_read error"); + if (n == 0) + break; + + switch (imsg.hdr.type) { + case IMSG_REQUEST_ADD: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(*rr)) + fatalx("invalid size of RDE request"); + + if ((rr = malloc(sizeof(*rr))) == NULL) + fatal("ripe_dispatch_rde"); + + memcpy(rr, imsg.data, sizeof(*rr)); + + if (imsg.hdr.peerid != 0) { + if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == + NULL) { + log_debug("unknown neighbor id %u", + imsg.hdr.peerid); + break; + } + add_entry(&nbr->rq_list, rr); + break; + } + + LIST_FOREACH(iface, &oeconf->iface_list, entry) { + add_entry(&iface->rq_list, rr); + } + break; + case IMSG_SEND_REQUEST: + if (imsg.hdr.peerid != 0) { + if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == + NULL) { + log_debug("unknown neighbor id %u", + imsg.hdr.peerid); + break; + } + send_request(&nbr->rq_list, NULL, nbr); + break; + } + + LIST_FOREACH(iface, &oeconf->iface_list, entry) { + send_request(&iface->rq_list, iface, NULL); + } + break; + case IMSG_RESPONSE_ADD: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(*rr)) + fatalx("invalid size of RDE request"); + + if ((rr = malloc(sizeof(*rr))) == NULL) + fatal("ripe_dispatch_rde"); + + memcpy(rr, imsg.data, sizeof(*rr)); + + if (imsg.hdr.peerid == 0) { + LIST_FOREACH(iface, &oeconf->iface_list, + entry) { + if ((iface->addr.s_addr & + iface->mask.s_addr) != + rr->address.s_addr || + iface->mask.s_addr != + rr->mask.s_addr) + add_entry(&iface->rp_list, + rr); + } + break; + } + + if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == NULL) { + log_debug("unknown neighbor id %u", + imsg.hdr.peerid); + break; + } + iface = nbr->iface; + if ((iface->addr.s_addr & iface->mask.s_addr) != + rr->address.s_addr || + iface->mask.s_addr != rr->mask.s_addr) + add_entry(&nbr->rp_list, rr); + break; + case IMSG_SEND_RESPONSE: + if (imsg.hdr.peerid == 0) { + LIST_FOREACH(iface, &oeconf->iface_list, + entry) { + send_response(&iface->rp_list, + iface, NULL); + } + break; + } + + if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == NULL) { + log_debug("unknown neighbor id %u", + imsg.hdr.peerid); + break; + } + send_response(&nbr->rp_list, NULL, nbr); + break; + case IMSG_SEND_TRIGGERED_UPDATE: + if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(struct + rip_route)) + fatalx("invalid size of RDE request"); + + rr = imsg.data; + + LIST_FOREACH(iface, &oeconf->iface_list, + entry) { + if (rr->ifindex != iface->ifindex) + send_triggered_update(iface, rr); + } + break; + case IMSG_CTL_END: + case IMSG_CTL_SHOW_RIB: + control_imsg_relay(&imsg); + break; + default: + log_debug("ripe_dispatch_rde: error handling imsg %d", + imsg.hdr.type); + break; + } + imsg_free(&imsg); + } + imsg_event_add(ibuf); +} + +void +ripe_shutdown(void) +{ + struct iface *iface; + + LIST_FOREACH(iface, &oeconf->iface_list, entry) { + if (if_fsm(iface, IF_EVT_DOWN)) { + log_debug("error stopping interface %s", + iface->name); + } + } + while ((iface = LIST_FIRST(&oeconf->iface_list)) != NULL) { + LIST_REMOVE(iface, entry); + if_del(iface); + } + + close(oeconf->rip_socket); + + /* clean up */ + msgbuf_write(&ibuf_rde->w); + msgbuf_clear(&ibuf_rde->w); + free(ibuf_rde); + msgbuf_write(&ibuf_main->w); + msgbuf_clear(&ibuf_main->w); + free(ibuf_main); + free(oeconf); + free(pkt_ptr); + + log_info("rip engine exiting"); + _exit(0); +} + +void +ripe_iface_ctl(struct ctl_conn *c, unsigned int idx) +{ + struct iface *iface; + struct ctl_iface *ictl; + + LIST_FOREACH(iface, &oeconf->iface_list, entry) { + if (idx == 0 || idx == iface->ifindex) { + ictl = if_to_ctl(iface); + imsg_compose(&c->ibuf, IMSG_CTL_SHOW_IFACE, + 0, 0, ictl, sizeof(struct ctl_iface)); + } + } +} + +void +ripe_nbr_ctl(struct ctl_conn *c) +{ + struct iface *iface; + struct nbr *nbr; + struct ctl_nbr *nctl; + + LIST_FOREACH(iface, &oeconf->iface_list, entry) + LIST_FOREACH(nbr, &iface->nbr_list, entry) { + nctl = nbr_to_ctl(nbr); + imsg_compose(&c->ibuf, + IMSG_CTL_SHOW_NBR, 0, 0, nctl, + sizeof(struct ctl_nbr)); + } + + imsg_compose(&c->ibuf, IMSG_CTL_END, 0, 0, NULL, 0); +} diff --git a/usr.sbin/ripd/ripe.h b/usr.sbin/ripd/ripe.h new file mode 100644 index 00000000000..cf7b8a1ea94 --- /dev/null +++ b/usr.sbin/ripd/ripe.h @@ -0,0 +1,146 @@ +/* $OpenBSD: ripe.h,v 1.1 2006/10/18 16:11:58 norby Exp $ */ + +/* + * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it> + * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _RIPE_H_ +#define _RIPE_H_ + +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netinet/in_systm.h> +#include <netinet/ip.h> + +TAILQ_HEAD(ctl_conns, ctl_conn) ctl_conns; +char *pkt_ptr; + +/* neighbor events */ +enum nbr_event { + NBR_EVT_RESPONSE_RCVD, + NBR_EVT_REQUEST_RCVD, + NBR_EVT_TIMEOUT, + NBR_EVT_KILL_NBR, + NBR_EVT_NOTHING +}; + +/* neighbor actions */ +enum nbr_action { + NBR_ACT_STRT_TIMER, + NBR_ACT_RST_TIMER, + NBR_ACT_DEL, + NBR_ACT_NOTHING +}; + +struct nbr_failed { + LIST_ENTRY(nbr_failed) entry; + struct in_addr addr; + u_int32_t auth_seq_num; +}; + +struct nbr { + LIST_ENTRY(nbr) entry, hash; + struct event timeout_timer; + struct in_addr addr; + struct in_addr id; + + struct packet_head rq_list; + struct packet_head rp_list; + + struct iface *iface; + + u_int32_t peerid; /* unique ID in DB */ + u_int32_t auth_seq_num; + u_int16_t port; + time_t uptime; + int state; + int flags; +}; + +/* packet */ +int send_packet(struct iface *, void *, size_t, struct sockaddr_in *); +void recv_packet(int, short, void *); +int gen_rip_hdr(struct buf *, u_int8_t); + +/* interface */ +void if_init(struct ripd_conf *, struct iface *); +int if_fsm(struct iface *, enum iface_event); +int if_set_mcast(struct iface *); +int if_set_mcast_ttl(int, u_int8_t); +int if_set_mcast_loop(int); +int if_set_opt(int); +int if_set_tos(int, int); +void if_set_recvbuf(int); +struct iface *if_new(struct kif *); +void if_del(struct iface *); +const char *if_event_name(int); +const char *if_action_name(int); +int if_join_group(struct iface *, struct in_addr *); +int if_leave_group(struct iface *, struct in_addr *); +struct ctl_iface *if_to_ctl(struct iface *); + +/* communications */ +void recv_request(struct iface *, struct nbr *, char *, u_int16_t); +void recv_response(struct iface *, struct nbr *, char *, u_int16_t); +void add_entry(struct packet_head *, struct rip_route *); +int send_triggered_update(struct iface *, struct rip_route *); +int send_request(struct packet_head *, struct iface *, struct nbr *); +int send_response(struct packet_head *, struct iface *, struct nbr *); +int start_report_timer(void); +void report_timer(int, short, void *); + +/* ripe.c */ +pid_t ripe(struct ripd_conf *, int [2], int [2], int [2]); +int ripe_imsg_compose_parent(int, pid_t, void *, u_int16_t); +int ripe_imsg_compose_rde(int, u_int32_t, pid_t, void *, + u_int16_t); +void ripe_dispatch_main(int, short, void *); +void ripe_dispatch_rde(int, short, void *); +void ripe_iface_ctl(struct ctl_conn *, unsigned int); +void ripe_nbr_ctl(struct ctl_conn *); + +/* auth.c */ +int auth_validate(char **, u_int16_t *, struct iface *, struct nbr *, + struct nbr_failed *, u_int32_t *); +int auth_gen(struct buf *, struct iface *); +int auth_add_trailer(struct buf *, struct iface *); +void md_list_add(struct auth_md_head *, u_int8_t, char *); +void md_list_copy(struct auth_md_head *, struct auth_md_head *); +void md_list_clr(struct auth_md_head *); + +/* neighbor.c */ +void nbr_init(u_int32_t); +struct nbr *nbr_new(u_int32_t, struct iface *, int); +void nbr_act_del(struct nbr *); + +struct nbr *nbr_find_ip(struct iface *, u_int32_t); +struct nbr *nbr_find_peerid(u_int32_t); +struct nbr_failed *nbr_failed_find(struct iface *, u_int32_t); +void nbr_failed_delete(struct iface *, struct nbr_failed *); + +int nbr_fsm(struct nbr *, enum nbr_event); + +void nbr_timeout_timer(int, short, void *); + +void nbr_act_delete(struct nbr *); + +const char *nbr_event_name(int); +const char *nbr_action_name(int); + +struct ctl_nbr *nbr_to_ctl(struct nbr *); + +#endif /* _RIPE_H_ */ |