+// SPDX-License-Identifier: ISC
/* $OpenBSD$ */
/*
* Copyright (c) 2013, 2016 Renato Westphal <renato@openbsd.org>
* Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
* Copyright (c) 2004, 2005, 2008 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 <zebra.h>
#include "sockopt.h"
-static struct iface *disc_find_iface(unsigned int, int,
- union ldpd_addr *);
-static void session_read(struct thread *thread);
-static void session_write(struct thread *thread);
-static ssize_t session_get_pdu(struct ibuf_read *, char **);
-static void tcp_close(struct tcp_conn *);
-static struct pending_conn *pending_conn_new(int, int, union ldpd_addr *);
-static void pending_conn_timeout(struct thread *thread);
+static struct iface *disc_find_iface(unsigned int, int, union ldpd_addr *);
+static void session_read(struct event *thread);
+static void session_write(struct event *thread);
+static ssize_t session_get_pdu(struct ibuf_read *, char **);
+static void tcp_close(struct tcp_conn *);
+static struct pending_conn *pending_conn_new(int, int, union ldpd_addr *);
+static void pending_conn_timeout(struct event *thread);
int
gen_ldp_hdr(struct ibuf *buf, uint16_t size)
}
/* Discovery functions */
-void disc_recv_packet(struct thread *thread)
+void disc_recv_packet(struct event *thread)
{
- int fd = THREAD_FD(thread);
- struct thread **threadp = THREAD_ARG(thread);
+ int fd = EVENT_FD(thread);
+ struct event **threadp = EVENT_ARG(thread);
union {
struct cmsghdr hdr;
struct in_addr lsr_id;
/* reschedule read */
- thread_add_read(master, disc_recv_packet, threadp, fd, threadp);
+ event_add_read(master, disc_recv_packet, threadp, fd, threadp);
/* setup buffer */
memset(&m, 0, sizeof(m));
if ((r = recvmsg(fd, &m, 0)) == -1) {
if (errno != EAGAIN && errno != EINTR)
- log_debug("%s: read error: %s", __func__,
- strerror(errno));
+ log_debug("%s: read error: %s", __func__, strerror(errno));
return;
}
multicast = (m.msg_flags & MSG_MCAST) ? 1 : 0;
#else
multicast = 0;
- for (cmsg = CMSG_FIRSTHDR(&m); cmsg != NULL;
- cmsg = CMSG_NXTHDR(&m, cmsg)) {
+ for (cmsg = CMSG_FIRSTHDR(&m); cmsg != NULL; cmsg = CMSG_NXTHDR(&m, cmsg)) {
#if defined(HAVE_IP_PKTINFO)
- if (af == AF_INET && cmsg->cmsg_level == IPPROTO_IP &&
+ if (af == AF_INET &&
+ cmsg->cmsg_level == IPPROTO_IP &&
cmsg->cmsg_type == IP_PKTINFO) {
struct in_pktinfo *pktinfo;
break;
}
#elif defined(HAVE_IP_RECVDSTADDR)
- if (af == AF_INET && cmsg->cmsg_level == IPPROTO_IP &&
+ if (af == AF_INET &&
+ cmsg->cmsg_level == IPPROTO_IP &&
cmsg->cmsg_type == IP_RECVDSTADDR) {
struct in_addr *addr;
#else
#error "Unsupported socket API"
#endif
- if (af == AF_INET6 && cmsg->cmsg_level == IPPROTO_IPV6 &&
+ if (af == AF_INET6 &&
+ cmsg->cmsg_level == IPPROTO_IPV6 &&
cmsg->cmsg_type == IPV6_PKTINFO) {
struct in6_pktinfo *pktinfo;
}
#endif /* MSG_MCAST */
if (bad_addr(af, &src)) {
- log_debug("%s: invalid source address: %s", __func__,
- log_addr(af, &src));
+ log_debug("%s: invalid source address: %s", __func__, log_addr(af, &src));
return;
}
ifindex = getsockopt_ifindex(af, &m);
/* check packet size */
len = (uint16_t)r;
if (len < (LDP_HDR_SIZE + LDP_MSG_SIZE) || len > LDP_MAX_LEN) {
- log_debug("%s: bad packet size, source %s", __func__,
- log_addr(af, &src));
+ log_debug("%s: bad packet size, source %s", __func__, log_addr(af, &src));
return;
}
return (iface);
}
-void session_accept(struct thread *thread)
+void session_accept(struct event *thread)
{
- int fd = THREAD_FD(thread);
+ int fd = EVENT_FD(thread);
struct sockaddr_storage src;
socklen_t len = sizeof(src);
int newfd;
*/
if (errno == ENFILE || errno == EMFILE) {
accept_pause();
- } else if (errno != EWOULDBLOCK && errno != EINTR &&
- errno != ECONNABORTED)
- log_debug("%s: accept error: %s", __func__,
- strerror(errno));
+ } else if (errno != EWOULDBLOCK && errno != EINTR && errno != ECONNABORTED)
+ log_debug("%s: accept error: %s", __func__, strerror(errno));
return;
}
sock_set_nonblock(newfd);
nbr_fsm(nbr, NBR_EVT_MATCH_ADJ);
}
-static void session_read(struct thread *thread)
+static void session_read(struct event *thread)
{
- int fd = THREAD_FD(thread);
- struct nbr *nbr = THREAD_ARG(thread);
+ int fd = EVENT_FD(thread);
+ struct nbr *nbr = EVENT_ARG(thread);
struct tcp_conn *tcp = nbr->tcp;
struct ldp_hdr *ldp_hdr;
struct ldp_msg *msg;
uint16_t pdu_len, msg_len, msg_size, max_pdu_len;
int ret;
- thread_add_read(master, session_read, nbr, fd, &tcp->rev);
+ event_add_read(master, session_read, nbr, fd, &tcp->rev);
if ((n = read(fd, tcp->rbuf->buf + tcp->rbuf->wpos,
sizeof(tcp->rbuf->buf) - tcp->rbuf->wpos)) == -1) {
max_pdu_len = nbr->max_pdu_len;
else
max_pdu_len = LDP_MAX_LEN;
- if (pdu_len < (LDP_HDR_PDU_LEN + LDP_MSG_SIZE) ||
- pdu_len > max_pdu_len) {
+ if (pdu_len < (LDP_HDR_PDU_LEN + LDP_MSG_SIZE) || pdu_len > max_pdu_len) {
session_shutdown(nbr, S_BAD_PDU_LEN, 0, 0);
free(buf);
return;
}
pdu_len -= LDP_HDR_PDU_LEN;
- if (ldp_hdr->lsr_id != nbr->id.s_addr ||
- ldp_hdr->lspace_id != 0) {
+ if (ldp_hdr->lsr_id != nbr->id.s_addr || ldp_hdr->lspace_id != 0) {
session_shutdown(nbr, S_BAD_LDP_ID, 0, 0);
free(buf);
return;
msg = (struct ldp_msg *)pdu;
type = ntohs(msg->type);
msg_len = ntohs(msg->length);
- if (msg_len < LDP_MSG_LEN ||
- (msg_len + LDP_MSG_DEAD_LEN) > pdu_len) {
- session_shutdown(nbr, S_BAD_MSG_LEN, msg->id,
- msg->type);
+ if (msg_len < LDP_MSG_LEN || (msg_len + LDP_MSG_DEAD_LEN) > pdu_len) {
+ session_shutdown(nbr, S_BAD_MSG_LEN, msg->id, msg->type);
free(buf);
return;
}
case MSG_TYPE_INIT:
if ((nbr->state != NBR_STA_INITIAL) &&
(nbr->state != NBR_STA_OPENSENT)) {
- session_shutdown(nbr, S_SHUTDOWN,
- msg->id, msg->type);
+ session_shutdown(nbr, S_SHUTDOWN, msg->id, msg->type);
free(buf);
return;
}
case MSG_TYPE_KEEPALIVE:
if ((nbr->state == NBR_STA_INITIAL) ||
(nbr->state == NBR_STA_OPENSENT)) {
- session_shutdown(nbr, S_SHUTDOWN,
- msg->id, msg->type);
+ session_shutdown(nbr, S_SHUTDOWN, msg->id, msg->type);
free(buf);
return;
}
break;
default:
if (nbr->state != NBR_STA_OPER) {
- session_shutdown(nbr, S_SHUTDOWN,
- msg->id, msg->type);
+ session_shutdown(nbr, S_SHUTDOWN, msg->id, msg->type);
free(buf);
return;
}
case MSG_TYPE_LABELWITHDRAW:
case MSG_TYPE_LABELRELEASE:
case MSG_TYPE_LABELABORTREQ:
- ret = recv_labelmessage(nbr, pdu, msg_size,
- type);
+ ret = recv_labelmessage(nbr, pdu, msg_size, type);
break;
default:
log_debug("%s: unknown LDP message from nbr %pI4",
__func__, &nbr->id);
if (!(ntohs(msg->type) & UNKNOWN_FLAG)) {
nbr->stats.unknown_msg++;
- send_notification(nbr->tcp,
- S_UNKNOWN_MSG, msg->id, msg->type);
+ send_notification(nbr->tcp, S_UNKNOWN_MSG, msg->id, msg->type);
}
/* ignore the message */
ret = 0;
free(buf);
}
-static void session_write(struct thread *thread)
+static void session_write(struct event *thread)
{
- struct tcp_conn *tcp = THREAD_ARG(thread);
+ struct tcp_conn *tcp = EVENT_ARG(thread);
struct nbr *nbr = tcp->nbr;
tcp->wbuf.ev = NULL;
switch (nbr->state) {
case NBR_STA_PRESENT:
if (nbr_pending_connect(nbr))
- THREAD_OFF(nbr->ev_connect);
+ EVENT_OFF(nbr->ev_connect);
break;
case NBR_STA_INITIAL:
case NBR_STA_OPENREC:
void
session_close(struct nbr *nbr)
{
- log_debug("%s: closing session with lsr-id %pI4", __func__,
- &nbr->id);
+ log_debug("%s: closing session with lsr-id %pI4", __func__, &nbr->id);
ldp_sync_fsm_nbr_event(nbr, LDP_SYNC_EVT_SESSION_CLOSE);
if ((tcp->rbuf = calloc(1, sizeof(struct ibuf_read))) == NULL)
fatal(__func__);
- thread_add_read(master, session_read, nbr, tcp->fd, &tcp->rev);
+ event_add_read(master, session_read, nbr, tcp->fd, &tcp->rev);
tcp->nbr = nbr;
}
evbuf_clear(&tcp->wbuf);
if (tcp->nbr) {
- THREAD_OFF(tcp->rev);
+ EVENT_OFF(tcp->rev);
free(tcp->rbuf);
tcp->nbr->tcp = NULL;
}
pconn->addr = *addr;
TAILQ_INSERT_TAIL(&global.pending_conns, pconn, entry);
pconn->ev_timeout = NULL;
- thread_add_timer(master, pending_conn_timeout, pconn, PENDING_CONN_TIMEOUT,
- &pconn->ev_timeout);
+ event_add_timer(master, pending_conn_timeout, pconn,
+ PENDING_CONN_TIMEOUT, &pconn->ev_timeout);
return (pconn);
}
void
pending_conn_del(struct pending_conn *pconn)
{
- THREAD_OFF(pconn->ev_timeout);
+ EVENT_OFF(pconn->ev_timeout);
TAILQ_REMOVE(&global.pending_conns, pconn, entry);
free(pconn);
}
struct pending_conn *pconn;
TAILQ_FOREACH(pconn, &global.pending_conns, entry)
- if (af == pconn->af &&
- ldp_addrcmp(af, addr, &pconn->addr) == 0)
+ if (af == pconn->af && ldp_addrcmp(af, addr, &pconn->addr) == 0)
return (pconn);
return (NULL);
}
-static void pending_conn_timeout(struct thread *thread)
+static void pending_conn_timeout(struct event *thread)
{
- struct pending_conn *pconn = THREAD_ARG(thread);
+ struct pending_conn *pconn = EVENT_ARG(thread);
struct tcp_conn *tcp;
pconn->ev_timeout = NULL;
projects / mirror_frr.git / blobdiff