/* $NetBSD: socketops.c,v 1.36 2022/06/26 17:55:38 riastradh Exp $ */ /* * Copyright (c) 2010 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Mihai Chelaru * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "conffile.h" #include "fsm.h" #include "ldp.h" #include "ldp_command.h" #include "tlv.h" #include "ldp_peer.h" #include "notifications.h" #include "tlv_stack.h" #include "mpls_interface.h" #include "label.h" #include "mpls_routes.h" #include "ldp_errors.h" #include "socketops.h" struct hello_info_head hello_info_head; static SLIST_HEAD(,hello_socket) hello_socket_head; int ls; /* TCP listening socket on port 646 */ int route_socket; /* used to see when a route is added/deleted */ int command_socket; /* Listening socket for interface command */ int current_msg_id = 0x233; int command_port = LDP_COMMAND_PORT; extern int replay_index; extern struct rt_msg replay_rt[REPLAY_MAX]; extern struct com_sock csockets[MAX_COMMAND_SOCKETS]; int ldp_hello_time = LDP_HELLO_TIME; int ldp_keepalive_time = LDP_KEEPALIVE_TIME; int ldp_holddown_time = LDP_HOLDTIME; int no_default_route = 1; int loop_detection = 0; bool may_connect; void recv_pdu(int); void send_hello_alarm(int); __dead static void bail_out(int); static void print_info(int); static int bind_socket(int s, int stype); static int set_tos(int); static int socket_reuse_port(int); static int get_local_addr(struct sockaddr_dl *, struct in_addr *); static int is_hello_socket(int); static int is_passive_if(const char *if_name); int create_hello_sockets() { struct ip_mreq mcast_addr; int s, joined_groups; struct ifaddrs *ifa, *ifb; uint lastifindex; #ifdef INET6 struct ipv6_mreq mcast_addr6; struct sockaddr_in6 *if_sa6; #endif struct hello_socket *hs; SLIST_INIT(&hello_socket_head); s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); if (s < 0) return s; debugp("INET4 socket created (%d)\n", s); /* * RFC5036 specifies we should listen to all subnet routers multicast * group */ mcast_addr.imr_multiaddr.s_addr = htonl(INADDR_ALLRTRS_GROUP); if (socket_reuse_port(s) < 0) goto chs_error; /* Bind it to port 646 */ if (bind_socket(s, AF_INET) == -1) { warnp("Cannot bind INET hello socket\n"); goto chs_error; } /* We don't need to receive back our messages */ if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, &(u_char){0}, sizeof(u_char)) == -1) { fatalp("INET setsockopt IP_MCAST_LOOP: %s\n", strerror(errno)); goto chs_error; } /* Finally join the group on all interfaces */ if (getifaddrs(&ifa) == -1) { fatalp("Cannot iterate interfaces\n"); return -1; } lastifindex = UINT_MAX; joined_groups = 0; for (ifb = ifa; ifb; ifb = ifb->ifa_next) { struct sockaddr_in *if_sa = (struct sockaddr_in *) ifb->ifa_addr; if (if_sa->sin_family != AF_INET || (!(ifb->ifa_flags & IFF_UP)) || (ifb->ifa_flags & IFF_LOOPBACK) || (!(ifb->ifa_flags & IFF_MULTICAST)) || (ntohl(if_sa->sin_addr.s_addr) >> 24 == IN_LOOPBACKNET) || is_passive_if(ifb->ifa_name) || lastifindex == if_nametoindex(ifb->ifa_name)) continue; lastifindex = if_nametoindex(ifb->ifa_name); mcast_addr.imr_interface.s_addr = if_sa->sin_addr.s_addr; debugp("Join IPv4 mcast on %s\n", ifb->ifa_name); if (setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mcast_addr, sizeof(mcast_addr)) == -1) { fatalp("setsockopt ADD_MEMBER: %s\n", strerror(errno)); goto chs_error; } joined_groups++; if (joined_groups == IP_MAX_MEMBERSHIPS) { warnp("Maximum group memberships reached for INET socket\n"); break; } } /* TTL:1 for IPv4 */ if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, &(int){1}, sizeof(int)) == -1) { fatalp("set mcast ttl: %s\n", strerror(errno)); goto chs_error; } /* TOS :0xc0 for IPv4 */ if (set_tos(s) == -1) { fatalp("set_tos: %s", strerror(errno)); goto chs_error; } /* we need to get the input interface for message processing */ if (setsockopt(s, IPPROTO_IP, IP_RECVIF, &(uint32_t){1}, sizeof(uint32_t)) == -1) { fatalp("Cannot set IP_RECVIF\n"); goto chs_error; } hs = (struct hello_socket *)malloc(sizeof(*hs)); if (hs == NULL) { fatalp("Cannot alloc hello_socket structure\n"); goto chs_error; } hs->type = AF_INET; hs->socket = s; SLIST_INSERT_HEAD(&hello_socket_head, hs, listentry); #ifdef INET6 /* * Now we do the same for IPv6 */ s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP); if (s < 0) { fatalp("Cannot create INET6 socket\n"); return -1; } debugp("INET6 socket created (%d)\n", s); if (socket_reuse_port(s) < 0) goto chs_error; if (bind_socket(s, AF_INET6) == -1) { fatalp("Cannot bind INET6 hello socket\n"); goto chs_error; } if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &(uint){0}, sizeof(uint)) == -1) { fatalp("INET6 setsocketopt IP_MCAST_LOOP: %s\n", strerror(errno)); goto chs_error; } lastifindex = UINT_MAX; mcast_addr6.ipv6mr_multiaddr = in6addr_linklocal_allrouters; for (ifb = ifa; ifb; ifb = ifb->ifa_next) { if_sa6 = (struct sockaddr_in6 *) ifb->ifa_addr; if (if_sa6->sin6_family != AF_INET6 || (!(ifb->ifa_flags & IFF_UP)) || (!(ifb->ifa_flags & IFF_MULTICAST)) || (ifb->ifa_flags & IFF_LOOPBACK) || is_passive_if(ifb->ifa_name) || IN6_IS_ADDR_LOOPBACK(&if_sa6->sin6_addr)) continue; /* * draft-ietf-mpls-ldp-ipv6-07 Section 5.1: * Additionally, the link-local * IPv6 address MUST be used as the source IP address in IPv6 * LDP Link Hellos. */ if (IN6_IS_ADDR_LINKLOCAL(&if_sa6->sin6_addr) == 0) continue; /* We should have only one LLADDR per interface, but... */ if (lastifindex == if_nametoindex(ifb->ifa_name)) continue; mcast_addr6.ipv6mr_interface = lastifindex = if_nametoindex(ifb->ifa_name); debugp("Join IPv6 mcast on %s\n", ifb->ifa_name); if (setsockopt(s, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *)&mcast_addr6, sizeof(mcast_addr6)) == -1) { fatalp("INET6 setsockopt JOIN: %s\n", strerror(errno)); goto chs_error; } } freeifaddrs(ifa); /* TTL: 255 for IPv6 - draft-ietf-mpls-ldp-ipv6-07 Section 9 */ if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &(int){255}, sizeof(int)) == -1) { fatalp("set mcast hops: %s\n", strerror(errno)); goto chs_error; } if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO, &(uint32_t){1}, sizeof(uint32_t)) == -1) goto chs_error; hs = (struct hello_socket *)malloc(sizeof(*hs)); if (hs == NULL) { fatalp("Memory alloc problem: hs\n"); goto chs_error; } hs->type = AF_INET6; hs->socket = s; SLIST_INSERT_HEAD(&hello_socket_head, hs, listentry); #endif return 0; chs_error: close(s); return -1; } /* Check if parameter is a hello socket */ int is_hello_socket(int s) { struct hello_socket *hs; SLIST_FOREACH(hs, &hello_socket_head, listentry) if (hs->socket == s) return 1; return 0; } /* Check if interface is passive */ static int is_passive_if(const char *if_name) { struct conf_interface *coif; SLIST_FOREACH(coif, &coifs_head, iflist) if (strncasecmp(if_name, coif->if_name, IF_NAMESIZE) == 0 && coif->passive != 0) return 1; return 0; } /* Sets the TTL to 1 as we don't want to transmit outside this subnet */ int set_ttl(int s) { int ret; if ((ret = setsockopt(s, IPPROTO_IP, IP_TTL, &(int){1}, sizeof(int))) == -1) fatalp("set_ttl: %s", strerror(errno)); return ret; } /* Sets TOS to 0xc0 aka IP Precedence 6 */ static int set_tos(int s) { int ret; if ((ret = setsockopt(s, IPPROTO_IP, IP_TOS, &(int){0xc0}, sizeof(int))) == -1) fatalp("set_tos: %s", strerror(errno)); return ret; } static int socket_reuse_port(int s) { int ret; if ((ret = setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &(int){1}, sizeof(int))) == -1) fatalp("socket_reuse_port: %s", strerror(errno)); return ret; } /* binds an UDP socket */ static int bind_socket(int s, int stype) { union sockunion su; assert (stype == AF_INET || stype == AF_INET6); memset(&su, 0, sizeof su); if (stype == AF_INET) { su.sin.sin_len = sizeof(su.sin); su.sin.sin_family = AF_INET; su.sin.sin_addr.s_addr = htonl(INADDR_ANY); su.sin.sin_port = htons(LDP_PORT); } #ifdef INET6 else if (stype == AF_INET6) { su.sin6.sin6_len = sizeof(su.sin6); su.sin6.sin6_family = AF_INET6; su.sin6.sin6_addr = in6addr_any; su.sin6.sin6_port = htons(LDP_PORT); } #endif if (bind(s, &su.sa, su.sa.sa_len)) { fatalp("bind_socket: %s\n", strerror(errno)); return -1; } return 0; } /* Create / bind the TCP socket */ int create_listening_socket(void) { struct sockaddr_in sa; int s; sa.sin_len = sizeof(sa); sa.sin_family = AF_INET; sa.sin_port = htons(LDP_PORT); sa.sin_addr.s_addr = htonl(INADDR_ANY); s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); if (s < 0) return s; if (bind(s, (struct sockaddr *) & sa, sizeof(sa))) { fatalp("bind: %s", strerror(errno)); close(s); return -1; } if (listen(s, 10) == -1) { fatalp("listen: %s", strerror(errno)); close(s); return -1; } /* if (set_tos(s) == -1) { fatalp("set_tos: %s", strerror(errno)); close(s); return -1; } */ return s; } /* * It's ugly. We need a function to pass all tlvs and create pdu but since I * use UDP socket only to send hellos, I didn't bother */ void send_hello(void) { struct hello_tlv *t; struct common_hello_tlv *cht; struct ldp_pdu *spdu; struct in_addr ldp_id; struct transport_address_tlv *trtlv; void *v; struct sockaddr_in sadest; /* Destination ALL_ROUTERS */ ssize_t sb = 0; /* sent bytes */ struct ifaddrs *ifa, *ifb; struct sockaddr_in *if_sa; int ip4socket = -1; uint lastifindex; struct hello_socket *hs; struct conf_interface *coif; bool bad_tr_addr; #ifdef INET6 struct sockaddr_in6 sadest6; int ip6socket = -1; #endif #define BASIC_HELLO_MSG_SIZE (sizeof(struct ldp_pdu) + /* PDU */ \ TLV_TYPE_LENGTH + MSGID_SIZE + /* Hello TLV */ \ /* Common Hello TLV */ \ sizeof(struct common_hello_tlv)) #define GENERAL_HELLO_MSG_SIZE BASIC_HELLO_MSG_SIZE + \ /* Transport Address */ \ sizeof(struct transport_address_tlv) #define IPV4_HELLO_MSG_SIZE BASIC_HELLO_MSG_SIZE + 4 + sizeof(struct in_addr) #define IPV6_HELLO_MSG_SIZE BASIC_HELLO_MSG_SIZE + 4 + sizeof(struct in6_addr) if ((v = calloc(1, GENERAL_HELLO_MSG_SIZE)) == NULL) { fatalp("alloc problem in send_hello()\n"); return; } spdu = (struct ldp_pdu *)((char *)v); t = (struct hello_tlv *)(spdu + 1); cht = &t->ch; /* Hello tlv struct includes CHT */ trtlv = (struct transport_address_tlv *)(t + 1); /* Prepare PDU envelope */ spdu->version = htons(LDP_VERSION); spdu->length = htons(IPV4_HELLO_MSG_SIZE - PDU_VER_LENGTH); inet_aton(LDP_ID, &ldp_id); spdu->ldp_id = ldp_id; /* Prepare Hello TLV */ t->type = htons(LDP_HELLO); t->length = htons(MSGID_SIZE + sizeof(struct common_hello_tlv) + IPV4_HELLO_MSG_SIZE - BASIC_HELLO_MSG_SIZE); /* * We used ID 0 instead of htonl(get_message_id()) because we've * seen hellos from Cisco routers doing the same thing */ t->messageid = 0; /* Prepare Common Hello attributes */ cht->type = htons(TLV_COMMON_HELLO); cht->length = htons(sizeof(cht->holdtime) + sizeof(cht->res)); cht->holdtime = htons(ldp_holddown_time); cht->res = 0; /* * Prepare Transport Address TLV RFC5036 says: "If this optional TLV * is not present the IPv4 source address for the UDP packet carrying * the Hello should be used." But we send it because everybody seems * to do so */ trtlv->type = htons(TLV_IPV4_TRANSPORT); trtlv->length = htons(sizeof(struct in_addr)); /* trtlv->address will be set for each socket */ /* Destination sockaddr */ memset(&sadest, 0, sizeof(sadest)); sadest.sin_len = sizeof(sadest); sadest.sin_family = AF_INET; sadest.sin_port = htons(LDP_PORT); sadest.sin_addr.s_addr = htonl(INADDR_ALLRTRS_GROUP); /* Find our socket */ SLIST_FOREACH(hs, &hello_socket_head, listentry) if (hs->type == AF_INET) { ip4socket = hs->socket; break; } assert(ip4socket >= 0); if (getifaddrs(&ifa) == -1) { free(v); fatalp("Cannot enumerate interfaces\n"); return; } lastifindex = UINT_MAX; /* Loop all interfaces in order to send IPv4 hellos */ for (ifb = ifa; ifb; ifb = ifb->ifa_next) { if_sa = (struct sockaddr_in *) ifb->ifa_addr; if (if_sa->sin_family != AF_INET || (!(ifb->ifa_flags & IFF_UP)) || (ifb->ifa_flags & IFF_LOOPBACK) || (!(ifb->ifa_flags & IFF_MULTICAST)) || is_passive_if(ifb->ifa_name) || (ntohl(if_sa->sin_addr.s_addr) >> 24 == IN_LOOPBACKNET) || lastifindex == if_nametoindex(ifb->ifa_name)) continue; /* Send only once per interface, using primary address */ if (lastifindex == if_nametoindex(ifb->ifa_name)) continue; /* Check if there is transport address set for this interface */ bad_tr_addr = false; SLIST_FOREACH(coif, &coifs_head, iflist) if (strncasecmp(coif->if_name, ifb->ifa_name, IF_NAMESIZE) == 0 && coif->tr_addr.s_addr != 0 && coif->tr_addr.s_addr != if_sa->sin_addr.s_addr) bad_tr_addr = true; if (bad_tr_addr == true) continue; lastifindex = if_nametoindex(ifb->ifa_name); if (setsockopt(ip4socket, IPPROTO_IP, IP_MULTICAST_IF, &if_sa->sin_addr, sizeof(struct in_addr)) == -1) { warnp("setsockopt failed: %s\n", strerror(errno)); continue; } trtlv->address.ip4addr.s_addr = if_sa->sin_addr.s_addr; /* Put it on the wire */ sb = sendto(ip4socket, v, IPV4_HELLO_MSG_SIZE, 0, (struct sockaddr *) & sadest, sizeof(sadest)); if (sb < (ssize_t)(IPV4_HELLO_MSG_SIZE)) fatalp("send: %s", strerror(errno)); else debugp("Sent (IPv4) %zd bytes on %s" " (PDU: %d, Hello TLV: %d, CH: %d, TR: %d)\n", sb, ifb->ifa_name, ntohs(spdu->length), ntohs(t->length), ntohs(cht->length), ntohs(trtlv->length)); } #ifdef INET6 /* Adjust lengths */ spdu->length = htons(IPV6_HELLO_MSG_SIZE - PDU_VER_LENGTH); t->length = htons(MSGID_SIZE + sizeof(struct common_hello_tlv) + IPV6_HELLO_MSG_SIZE - BASIC_HELLO_MSG_SIZE); trtlv->length = htons(sizeof(struct in6_addr)); trtlv->type = htons(TLV_IPV6_TRANSPORT); /* Prepare destination sockaddr */ memset(&sadest6, 0, sizeof(sadest6)); sadest6.sin6_len = sizeof(sadest6); sadest6.sin6_family = AF_INET6; sadest6.sin6_port = htons(LDP_PORT); sadest6.sin6_addr = in6addr_linklocal_allrouters; SLIST_FOREACH(hs, &hello_socket_head, listentry) if (hs->type == AF_INET6) { ip6socket = hs->socket; break; } lastifindex = UINT_MAX; for (ifb = ifa; ifb; ifb = ifb->ifa_next) { struct sockaddr_in6 * if_sa6 = (struct sockaddr_in6 *) ifb->ifa_addr; if (if_sa6->sin6_family != AF_INET6 || (!(ifb->ifa_flags & IFF_UP)) || (!(ifb->ifa_flags & IFF_MULTICAST)) || (ifb->ifa_flags & IFF_LOOPBACK) || is_passive_if(ifb->ifa_name) || IN6_IS_ADDR_LOOPBACK(&if_sa6->sin6_addr)) continue; /* * draft-ietf-mpls-ldp-ipv6-07 Section 5.1: * Additionally, the link-local * IPv6 address MUST be used as the source IP address in IPv6 * LDP Link Hellos. */ if (IN6_IS_ADDR_LINKLOCAL(&if_sa6->sin6_addr) == 0) continue; /* We should have only one LLADDR per interface, but... */ if (lastifindex == if_nametoindex(ifb->ifa_name)) continue; lastifindex = if_nametoindex(ifb->ifa_name); if (setsockopt(ip6socket, IPPROTO_IPV6, IPV6_MULTICAST_IF, &lastifindex, sizeof(int)) == -1) { fatalp("ssopt6 IPV6_MULTICAST_IF failed: %s for %s\n", strerror(errno), ifb->ifa_name); continue; } memcpy(&trtlv->address.ip6addr, &if_sa6->sin6_addr, sizeof(struct in6_addr)); /* Put it on the wire */ sb = sendto(ip6socket, v, IPV6_HELLO_MSG_SIZE, 0, (struct sockaddr *)&sadest6, sizeof(sadest6)); if (sb < (ssize_t)(IPV6_HELLO_MSG_SIZE)) fatalp("send6: %s", strerror(errno)); else debugp("Sent (IPv6) %zd bytes on %s " "(PDU: %d, Hello TLV: %d, CH: %d TR: %d)\n", sb, ifb->ifa_name, htons(spdu->length), htons(t->length), htons(cht->length), htons(trtlv->length)); } #endif freeifaddrs(ifa); free(v); } int get_message_id(void) { current_msg_id++; return current_msg_id; } static int get_local_addr(struct sockaddr_dl *sdl, struct in_addr *sin) { struct ifaddrs *ifa, *ifb; struct sockaddr_in *sinet; if (sdl == NULL) return -1; if (getifaddrs(&ifa) == -1) return -1; for (ifb = ifa; ifb; ifb = ifb->ifa_next) if (ifb->ifa_addr->sa_family == AF_INET) { if (if_nametoindex(ifb->ifa_name) != sdl->sdl_index) continue; sinet = (struct sockaddr_in*) ifb->ifa_addr; sin->s_addr = sinet->sin_addr.s_addr; freeifaddrs(ifa); return 0; } freeifaddrs(ifa); return -1; } /* Receive PDUs on Multicast UDP socket */ void recv_pdu(int sock) { struct ldp_pdu rpdu; int c, i; struct msghdr msg; struct iovec iov[1]; unsigned char recvspace[MAX_PDU_SIZE]; struct hello_tlv *t; union sockunion sender; struct sockaddr_dl *sdl = NULL; struct in_addr my_ldp_addr, local_addr; struct cmsghdr *cmptr; union { struct cmsghdr cm; char control[1024]; } control_un; memset(&msg, 0, sizeof(msg)); msg.msg_control = control_un.control; msg.msg_controllen = sizeof(control_un.control); msg.msg_flags = 0; msg.msg_name = &sender; msg.msg_namelen = sizeof(sender); iov[0].iov_base = recvspace; iov[0].iov_len = sizeof(recvspace); msg.msg_iov = iov; msg.msg_iovlen = 1; c = recvmsg(sock, &msg, MSG_WAITALL); /* Check to see if this is larger than MIN_PDU_SIZE */ if (c < MIN_PDU_SIZE) return; /* Read the PDU */ i = get_pdu(recvspace, &rpdu); debugp("recv_pdu(%d): PDU(size: %d) from: %s\n", sock, c, satos(&sender.sa)); /* We currently understand Version 1 */ if (rpdu.version != LDP_VERSION) { warnp("recv_pdu: Version mismatch\n"); return; } /* Check if it's our hello */ inet_aton(LDP_ID, &my_ldp_addr); if (rpdu.ldp_id.s_addr == my_ldp_addr.s_addr) { /* It should not be looped. We set MULTICAST_LOOP 0 */ fatalp("Received our PDU. Ignoring it\n"); return; } if (msg.msg_controllen < (socklen_t)sizeof(struct cmsghdr) || (msg.msg_flags & MSG_CTRUNC)) local_addr.s_addr = my_ldp_addr.s_addr; else { for (cmptr = CMSG_FIRSTHDR(&msg); cmptr != NULL; cmptr = CMSG_NXTHDR(&msg, cmptr)) if (cmptr->cmsg_level == IPPROTO_IP && cmptr->cmsg_type == IP_RECVIF) { sdl = (struct sockaddr_dl *) CMSG_DATA(cmptr); break; } if (get_local_addr(sdl, &local_addr) != 0) local_addr.s_addr = my_ldp_addr.s_addr; } debugp("Read %d bytes from address %s Length: %.4d Version: %d\n", c, inet_ntoa(rpdu.ldp_id), rpdu.length, rpdu.version); /* Fill the TLV messages */ t = get_hello_tlv(recvspace + i, c - i); run_ldp_hello(&rpdu, t, &sender.sa, &local_addr, sock, may_connect); } void send_hello_alarm(int unused) { struct ldp_peer *p, *ptmp; struct hello_info *hi, *hinext; time_t t = time(NULL); int olderrno = errno; if (may_connect == false) may_connect = true; /* Send hellos */ if (!(t % ldp_hello_time)) send_hello(); /* Timeout -- */ SLIST_FOREACH(p, &ldp_peer_head, peers) p->timeout--; /* Check for timeout */ SLIST_FOREACH_SAFE(p, &ldp_peer_head, peers, ptmp) if (p->timeout < 1) switch (p->state) { case LDP_PEER_HOLDDOWN: debugp("LDP holddown expired for peer %s\n", inet_ntoa(p->ldp_id)); ldp_peer_delete(p); break; case LDP_PEER_ESTABLISHED: case LDP_PEER_CONNECTED: send_notification(p, 0, NOTIF_FATAL|NOTIF_KEEP_ALIVE_TIMER_EXPIRED); warnp("Keepalive expired for %s\n", inet_ntoa(p->ldp_id)); ldp_peer_holddown(p); break; } /* switch */ /* send keepalives */ if (!(t % ldp_keepalive_time)) { SLIST_FOREACH(p, &ldp_peer_head, peers) if (p->state == LDP_PEER_ESTABLISHED) { debugp("Sending KeepAlive to %s\n", inet_ntoa(p->ldp_id)); keep_alive(p); } } /* Decrement and Check hello keepalives */ SLIST_FOREACH_SAFE(hi, &hello_info_head, infos, hinext) { if (hi->keepalive != 0xFFFF) hi->keepalive--; if (hi->keepalive < 1) SLIST_REMOVE(&hello_info_head, hi, hello_info, infos); } /* Set the alarm again and bail out */ alarm(1); errno = olderrno; } static void bail_out(int x) { ldp_peer_holddown_all(); flush_mpls_routes(); exit(0); } static void print_info(int x) { printf("Info for %s\n-------\n", LDP_ID); printf("Neighbours:\n"); show_neighbours(1, NULL); printf("Bindings:\n"); show_bindings(1, NULL); printf("Labels:\n"); show_labels(1, NULL); printf("--------\n"); } /* * The big poll that catches every single event * on every socket. */ int the_big_loop(void) { int sock_error; uint32_t i; socklen_t sock_error_size = sizeof(int); struct ldp_peer *p; struct com_sock *cs; struct pollfd pfd[MAX_POLL_FDS]; struct hello_socket *hs; nfds_t pollsum; #ifdef RO_MSGFILTER unsigned char msgfilter[] = { RTM_NEWADDR, RTM_DELADDR, RTM_ADD, RTM_DELETE, RTM_CHANGE, }; #endif assert(MAX_POLL_FDS > 5); SLIST_INIT(&hello_info_head); signal(SIGALRM, send_hello_alarm); signal(SIGPIPE, SIG_IGN); signal(SIGINT, bail_out); signal(SIGTERM, bail_out); signal(SIGINFO, print_info); /* Send first hellos in 5 seconds. Avoid No hello notifications */ may_connect = false; alarm(5); route_socket = socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC); setsockopt(route_socket, SOL_SOCKET, SO_USELOOPBACK, &(int){0}, sizeof(int)); #ifdef RO_MSGFILTER setsockopt(route_socket, PF_ROUTE, RO_MSGFILTER, &msgfilter, sizeof(msgfilter)); #endif sock_error = bind_current_routes(); if (sock_error != LDP_E_OK) { fatalp("Cannot get current routes\n"); return sock_error; } for (;;) { pfd[0].fd = ls; pfd[0].events = POLLRDNORM; pfd[0].revents = 0; pfd[1].fd = route_socket; pfd[1].events = POLLRDNORM; pfd[1].revents = 0; pfd[2].fd = command_socket; pfd[2].events = POLLRDNORM; pfd[2].revents = 0; /* Hello sockets */ pollsum = 3; SLIST_FOREACH(hs, &hello_socket_head, listentry) { pfd[pollsum].fd = hs->socket; pfd[pollsum].events = POLLIN; pfd[pollsum].revents = 0; pollsum++; } /* Command sockets */ for (i=0; i < MAX_COMMAND_SOCKETS; i++) if (csockets[i].socket != -1) { if (pollsum >= MAX_POLL_FDS) break; pfd[pollsum].fd = csockets[i].socket; pfd[pollsum].events = POLLIN; pfd[pollsum].revents = 0; pollsum++; } /* LDP Peer sockets */ SLIST_FOREACH(p, &ldp_peer_head, peers) { if (p->socket < 1) continue; switch (p->state) { case LDP_PEER_CONNECTED: case LDP_PEER_ESTABLISHED: if (pollsum >= MAX_POLL_FDS) break; pfd[pollsum].fd = p->socket; pfd[pollsum].events = POLLRDNORM; pfd[pollsum].revents = 0; pollsum++; break; case LDP_PEER_CONNECTING: if (pollsum >= MAX_POLL_FDS) break; pfd[pollsum].fd = p->socket; pfd[pollsum].events = POLLWRNORM; pfd[pollsum].revents = 0; pollsum++; break; } } if (pollsum >= MAX_POLL_FDS) { fatalp("Too many sockets. Increase MAX_POLL_FDS\n"); return LDP_E_TOO_MANY_FDS; } if (poll(pfd, pollsum, INFTIM) < 0) { if (errno != EINTR) fatalp("poll: %s", strerror(errno)); continue; } for (i = 0; i < pollsum; i++) { if ((pfd[i].revents & POLLRDNORM) || (pfd[i].revents & POLLIN)) { if(pfd[i].fd == ls) new_peer_connection(); else if (pfd[i].fd == route_socket) { struct rt_msg xbuf; int l, rtmlen = sizeof(xbuf); /* Read at least rtm_msglen */ l = recv(route_socket, &xbuf, sizeof(u_short), MSG_PEEK); if (l == sizeof(u_short)) rtmlen = xbuf.m_rtm.rtm_msglen; do { l = recv(route_socket, &xbuf, rtmlen, MSG_WAITALL); } while ((l == -1) && (errno == EINTR)); if (l == -1) break; check_route(&xbuf, l); } else if (is_hello_socket(pfd[i].fd) == 1) { /* Receiving hello socket */ recv_pdu(pfd[i].fd); } else if (pfd[i].fd == command_socket) { command_accept(command_socket); } else if ((cs = is_command_socket(pfd[i].fd)) != NULL) { command_dispatch(cs); } else { /* ldp peer socket */ p = get_ldp_peer_by_socket(pfd[i].fd); if (p) recv_session_pdu(p); } } else if(pfd[i].revents & POLLWRNORM) { p = get_ldp_peer_by_socket(pfd[i].fd); if (!p) continue; assert(p->state == LDP_PEER_CONNECTING); if (getsockopt(pfd[i].fd, SOL_SOCKET, SO_ERROR, &sock_error, &sock_error_size) != 0 || sock_error != 0) { ldp_peer_holddown(p); sock_error = 0; } else { p->state = LDP_PEER_CONNECTED; send_initialize(p); } } } for (int ri = 0; ri < replay_index; ri++) { debugp("Replaying: PID %d, SEQ %d\n", replay_rt[ri].m_rtm.rtm_pid, replay_rt[ri].m_rtm.rtm_seq); check_route(&replay_rt[ri], sizeof(struct rt_msg)); } replay_index = 0; } /* for (;;) */ } void new_peer_connection() { union sockunion peer_address, my_address; struct in_addr *peer_ldp_id = NULL; struct hello_info *hi; int s; s = accept(ls, &peer_address.sa, & (socklen_t) { sizeof(union sockunion) } ); if (s < 0) { fatalp("accept: %s", strerror(errno)); return; } if (getsockname(s, &my_address.sa, & (socklen_t) { sizeof(union sockunion) } )) { fatalp("new_peer_connection(): cannot getsockname\n"); close(s); return; } if (peer_address.sa.sa_family == AF_INET) peer_address.sin.sin_port = 0; else if (peer_address.sa.sa_family == AF_INET6) peer_address.sin6.sin6_port = 0; else { fatalp("Unknown peer address family\n"); close(s); return; } /* Already peered or in holddown ? */ if (get_ldp_peer(&peer_address.sa) != NULL) { close(s); return; } warnp("Accepted a connection from %s\n", satos(&peer_address.sa)); /* Verify if it should connect - XXX: no check for INET6 */ if (peer_address.sa.sa_family == AF_INET && ntohl(peer_address.sin.sin_addr.s_addr) < ntohl(my_address.sin.sin_addr.s_addr)) { fatalp("Peer %s: connect from lower ID\n", satos(&peer_address.sa)); close(s); return; } /* Match hello info in order to get ldp_id */ SLIST_FOREACH(hi, &hello_info_head, infos) { if (sockaddr_cmp(&peer_address.sa, &hi->transport_address.sa) == 0) { peer_ldp_id = &hi->ldp_id; break; } } if (peer_ldp_id == NULL) { warnp("Got connection from %s, but no hello info exists\n", satos(&peer_address.sa)); close(s); return; } else ldp_peer_new(peer_ldp_id, &peer_address.sa, NULL, ldp_holddown_time, s); } void send_initialize(const struct ldp_peer * p) { struct init_tlv ti; ti.type = htons(LDP_INITIALIZE); ti.length = htons(sizeof(struct init_tlv) - TLV_TYPE_LENGTH); ti.messageid = htonl(get_message_id()); ti.cs_type = htons(TLV_COMMON_SESSION); ti.cs_len = htons(CS_LEN); ti.cs_version = htons(LDP_VERSION); ti.cs_keepalive = htons(2 * ldp_keepalive_time); ti.cs_adpvlim = 0; ti.cs_maxpdulen = htons(MAX_PDU_SIZE); ti.cs_peeraddress.s_addr = p->ldp_id.s_addr; ti.cs_peeraddrspace = 0; send_tlv(p, (struct tlv *) (void *) &ti); } void keep_alive(const struct ldp_peer * p) { struct ka_tlv kt; kt.type = htons(LDP_KEEPALIVE); kt.length = htons(sizeof(kt.messageid)); kt.messageid = htonl(get_message_id()); send_tlv(p, (struct tlv *) (void *) &kt); } /* * Process a message received from a peer */ void recv_session_pdu(struct ldp_peer * p) { struct ldp_pdu *rpdu; struct address_tlv *atlv; struct al_tlv *altlv; struct init_tlv *itlv; struct label_map_tlv *lmtlv; struct fec_tlv *fectlv; struct label_tlv *labeltlv; struct notification_tlv *nottlv; struct hello_info *hi; int c; int32_t wo = 0; struct tlv *ttmp; unsigned char recvspace[MAX_PDU_SIZE]; memset(recvspace, 0, MAX_PDU_SIZE); do { c = recv(p->socket, (void *) recvspace, MAX_PDU_SIZE, MSG_PEEK); } while (c == -1 && errno == EINTR); debugp("Ready to read %d bytes\n", c); if (c < 1) { /* Session closed */ warnp("Error in connection with %s\n", inet_ntoa(p->ldp_id)); ldp_peer_holddown(p); return; } if (c > MAX_PDU_SIZE) { debugp("Incoming PDU size exceeds MAX_PDU_SIZE !\n"); return; } if (c < MIN_PDU_SIZE) { debugp("PDU too small received from peer %s\n", inet_ntoa(p->ldp_id)); return; } rpdu = (struct ldp_pdu *) recvspace; do { c = recv(p->socket, (void *) recvspace, ntohs(rpdu->length) + PDU_VER_LENGTH, MSG_WAITALL); } while (c == -1 && errno == EINTR); /* sanity check */ if (check_recv_pdu(p, rpdu, c) != 0) return; debugp("Read %d bytes, PDU size: %d bytes\n", c, ntohs(rpdu->length)); wo = sizeof(struct ldp_pdu); while (wo + TLV_TYPE_LENGTH < (uint)c) { ttmp = (struct tlv *) (&recvspace[wo]); if ((ntohs(ttmp->type) != LDP_KEEPALIVE) && (ntohs(ttmp->type) != LDP_LABEL_MAPPING)) { debugp("Got Type: 0x%.4X (Length: %d) from %s\n", ntohs(ttmp->type), ntohs(ttmp->length), inet_ntoa(p->ldp_id)); } else debugp("Got Type: 0x%.4X (Length: %d) from %s\n", ntohs(ttmp->type), ntohs(ttmp->length), inet_ntoa(p->ldp_id)); /* Should we get the message ? */ if (p->state != LDP_PEER_ESTABLISHED && ntohs(ttmp->type) != LDP_INITIALIZE && ntohs(ttmp->type) != LDP_KEEPALIVE && ntohs(ttmp->type) != LDP_NOTIFICATION) break; /* The big switch */ switch (ntohs(ttmp->type)) { case LDP_INITIALIZE: itlv = (struct init_tlv *)ttmp; /* Check size */ if (ntohs(itlv->length) < sizeof(struct init_tlv) - TLV_TYPE_LENGTH) { debugp("Bad size\n"); send_notification(p, 0, NOTIF_BAD_PDU_LEN | NOTIF_FATAL); ldp_peer_holddown(p); break; } /* Check version */ if (ntohs(itlv->cs_version) != LDP_VERSION) { debugp("Bad version"); send_notification(p, ntohl(itlv->messageid), NOTIF_BAD_LDP_VER | NOTIF_FATAL); ldp_peer_holddown(p); break; } /* Check if we got any hello from this one */ SLIST_FOREACH(hi, &hello_info_head, infos) if (hi->ldp_id.s_addr == rpdu->ldp_id.s_addr) break; if (hi == NULL) { debugp("No hello. Moving peer to holddown\n"); send_notification(p, ntohl(itlv->messageid), NOTIF_SESSION_REJECTED_NO_HELLO | NOTIF_FATAL); ldp_peer_holddown(p); break; } if (!p->master) { send_initialize(p); keep_alive(p); } else { p->state = LDP_PEER_ESTABLISHED; p->established_t = time(NULL); keep_alive(p); /* * Recheck here ldp id because we accepted * connection without knowing who is it for sure */ p->ldp_id.s_addr = rpdu->ldp_id.s_addr; fatalp("LDP neighbour %s is UP\n", inet_ntoa(p->ldp_id)); mpls_add_ldp_peer(p); send_addresses(p); send_all_bindings(p); } break; case LDP_KEEPALIVE: if ((p->state == LDP_PEER_CONNECTED) && (!p->master)) { p->state = LDP_PEER_ESTABLISHED; p->established_t = time(NULL); fatalp("LDP neighbour %s is UP\n", inet_ntoa(p->ldp_id)); mpls_add_ldp_peer(p); send_addresses(p); send_all_bindings(p); } p->timeout = p->holdtime; break; case LDP_ADDRESS: /* Add peer addresses */ atlv = (struct address_tlv *) ttmp; altlv = (struct al_tlv *) (&atlv[1]); add_ifaddresses(p, altlv); /* * try to see if we have labels with null peer that * would match the new peer */ label_check_assoc(p); print_bounded_addresses(p); break; case LDP_ADDRESS_WITHDRAW: atlv = (struct address_tlv *) ttmp; altlv = (struct al_tlv *) (&atlv[1]); del_ifaddresses(p, altlv); break; case LDP_LABEL_MAPPING: lmtlv = (struct label_map_tlv *) ttmp; fectlv = (struct fec_tlv *) (&lmtlv[1]); labeltlv = (struct label_tlv *)((unsigned char *)fectlv + ntohs(fectlv->length) + TLV_TYPE_LENGTH); map_label(p, fectlv, labeltlv); break; case LDP_LABEL_REQUEST: lmtlv = (struct label_map_tlv *) ttmp; fectlv = (struct fec_tlv *) (&lmtlv[1]); switch (request_respond(p, lmtlv, fectlv)) { case LDP_E_BAD_FEC: send_notification(p, ntohl(lmtlv->messageid), NOTIF_UNKNOWN_TLV); break; case LDP_E_BAD_AF: send_notification(p, ntohl(lmtlv->messageid), NOTIF_UNSUPPORTED_AF); break; case LDP_E_NO_SUCH_ROUTE: send_notification(p, ntohl(lmtlv->messageid), NOTIF_NO_ROUTE); break; } break; case LDP_LABEL_WITHDRAW: lmtlv = (struct label_map_tlv *) ttmp; fectlv = (struct fec_tlv *) (&lmtlv[1]); if (withdraw_label(p, fectlv) == LDP_E_OK) { /* Send RELEASE */ prepare_release(ttmp); send_tlv(p, ttmp); } break; case LDP_LABEL_RELEASE: /* * XXX: we need to make a timed queue... * For now I just assume peers are processing messages * correctly so I just ignore confirmations */ wo = -1; /* Ignore rest of message */ break; case LDP_LABEL_ABORT: /* XXX: For now I pretend I can process everything * RFC 5036, Section 3.5.9.1 * If an LSR receives a Label Abort Request Message after it * has responded to the Label Request in question with a Label * Mapping message or a Notification message, it ignores the * abort request. */ wo = -1; break; case LDP_NOTIFICATION: nottlv = (struct notification_tlv *) ttmp; nottlv->st_code = ntohl(nottlv->st_code); fatalp("Got notification 0x%X from peer %s\n", nottlv->st_code, inet_ntoa(p->ldp_id)); if (nottlv->st_code >> 31) { fatalp("LDP peer %s signalized %s\n", inet_ntoa(p->ldp_id), NOTIF_STR[(nottlv->st_code << 1) >> 1]); ldp_peer_holddown(p); wo = -1; } break; case LDP_HELLO: /* No hellos should came on tcp session */ wo = -1; break; default: warnp("Unknown TLV received from %s\n", inet_ntoa(p->ldp_id)); debug_tlv(ttmp); wo = -1;/* discard the rest of the message */ break; } if (wo < 0) { debugp("Discarding the rest of the message\n"); break; } else { wo += ntohs(ttmp->length) + TLV_TYPE_LENGTH; debugp("WORKED ON %u bytes (Left %d)\n", wo, c - wo); } } /* while */ } /* Sends a pdu, tlv pair to a connected peer */ int send_message(const struct ldp_peer * p, const struct ldp_pdu * pdu, const struct tlv * t) { unsigned char sendspace[MAX_PDU_SIZE]; /* Check if peer is connected */ switch (p->state) { case LDP_PEER_CONNECTED: case LDP_PEER_ESTABLISHED: break; default: return -1; } /* Check length validity first */ if (ntohs(pdu->length) != ntohs(t->length) + TLV_TYPE_LENGTH + PDU_PAYLOAD_LENGTH) { fatalp("LDP: TLV - PDU incompability. Message discarded\n"); fatalp("LDP: TLV len %d - PDU len %d\n", ntohs(t->length), ntohs(pdu->length)); return -1; } if (ntohs(t->length) + PDU_VER_LENGTH > MAX_PDU_SIZE) { fatalp("Message to large discarded\n"); return -1; } /* Arrange them in a buffer and send */ memcpy(sendspace, pdu, sizeof(struct ldp_pdu)); memcpy(sendspace + sizeof(struct ldp_pdu), t, ntohs(t->length) + TLV_TYPE_LENGTH); /* Report keepalives only for DEBUG */ if ((ntohs(t->type) != 0x201) && (ntohs(t->type) != 0x400)) { debugp("Sending message type 0x%.4X to %s (size: %d)\n", ntohs(t->type), inet_ntoa(p->ldp_id), ntohs(t->length)); } else /* downgraded from warnp to debugp for now */ debugp("Sending message type 0x%.4X to %s (size: %d)\n", ntohs(t->type), inet_ntoa(p->ldp_id), ntohs(t->length)); /* Send it finally */ return send(p->socket, sendspace, ntohs(pdu->length) + PDU_VER_LENGTH, 0); } /* * Encapsulates TLV into a PDU and sends it to a peer */ int send_tlv(const struct ldp_peer * p, const struct tlv * t) { struct in_addr ldp_id; struct ldp_pdu pdu; inet_aton(LDP_ID, &ldp_id); pdu.version = htons(LDP_VERSION); pdu.ldp_id = ldp_id; pdu.label_space = 0; pdu.length = htons(ntohs(t->length) + TLV_TYPE_LENGTH + PDU_PAYLOAD_LENGTH); return send_message(p, &pdu, t); } int send_addresses(const struct ldp_peer * p) { struct address_list_tlv *t; int ret; t = build_address_list_tlv(); ret = send_tlv(p, (struct tlv *) t); free(t); return ret; }