diff options
Diffstat (limited to 'src/protocol.c')
| -rw-r--r-- | src/protocol.c | 309 |
1 files changed, 309 insertions, 0 deletions
diff --git a/src/protocol.c b/src/protocol.c new file mode 100644 index 0000000..25ed6b7 --- /dev/null +++ b/src/protocol.c @@ -0,0 +1,309 @@ +/* + * Protocol registration functions. + * + * Copyright 2000-2012 Willy Tarreau <w@1wt.eu> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version + * 2 of the License, or (at your option) any later version. + * + */ + +#include <sys/types.h> +#include <sys/socket.h> + +#include <haproxy/api.h> +#include <haproxy/errors.h> +#include <haproxy/global.h> +#include <haproxy/list.h> +#include <haproxy/listener.h> +#include <haproxy/proto_quic.h> +#include <haproxy/protocol.h> +#include <haproxy/proxy.h> +#include <haproxy/sock.h> +#include <haproxy/tools.h> + + +/* List head of all registered protocols */ +static struct list protocols = LIST_HEAD_INIT(protocols); +struct protocol *__protocol_by_family[AF_CUST_MAX][PROTO_NUM_TYPES][2] __read_mostly = { }; + +/* This is the global spinlock we may need to register/unregister listeners or + * protocols. Its main purpose is in fact to serialize the rare stop/deinit() + * phases. + */ +__decl_spinlock(proto_lock); + +/* Registers the protocol <proto> */ +void protocol_register(struct protocol *proto) +{ + int sock_domain = proto->fam->sock_domain; + + BUG_ON(sock_domain < 0 || sock_domain >= AF_CUST_MAX); + BUG_ON(proto->proto_type >= PROTO_NUM_TYPES); + + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + LIST_APPEND(&protocols, &proto->list); + __protocol_by_family[sock_domain] + [proto->proto_type] + [proto->xprt_type == PROTO_TYPE_DGRAM] = proto; + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); +} + +/* Unregisters the protocol <proto>. Note that all listeners must have + * previously been unbound. + */ +void protocol_unregister(struct protocol *proto) +{ + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + LIST_DELETE(&proto->list); + LIST_INIT(&proto->list); + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); +} + +/* clears flag <flag> on all protocols. */ +void protocol_clrf_all(uint flag) +{ + struct protocol *proto; + + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + list_for_each_entry(proto, &protocols, list) + proto->flags &= ~flag; + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); +} + +/* sets flag <flag> on all protocols. */ +void protocol_setf_all(uint flag) +{ + struct protocol *proto; + + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + list_for_each_entry(proto, &protocols, list) + proto->flags |= flag; + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); +} + +/* Checks if protocol <proto> supports PROTO_F flag <flag>. Returns zero if not, + * non-zero if supported. It may return a cached value from a previous test, + * and may run live tests then update the proto's flags to cache a result. It's + * better to call it only if needed so that it doesn't result in modules being + * loaded in case of a live test. It is only supposed to be used during boot. + */ +int protocol_supports_flag(struct protocol *proto, uint flag) +{ + if (flag == PROTO_F_REUSEPORT_SUPPORTED) { + int ret = 0; + + /* check if the protocol supports SO_REUSEPORT */ + if (!(_HA_ATOMIC_LOAD(&proto->flags) & PROTO_F_REUSEPORT_SUPPORTED)) + return 0; + + /* at least nobody said it was not supported */ + if (_HA_ATOMIC_LOAD(&proto->flags) & PROTO_F_REUSEPORT_TESTED) + return 1; + + /* run a live check */ + ret = _sock_supports_reuseport(proto->fam, proto->sock_type, proto->sock_prot); + if (!ret) + _HA_ATOMIC_AND(&proto->flags, ~PROTO_F_REUSEPORT_SUPPORTED); + + _HA_ATOMIC_OR(&proto->flags, PROTO_F_REUSEPORT_TESTED); + return ret; + } + return 0; +} + +#ifdef USE_QUIC +/* Return 1 if QUIC protocol may be bound, 0 if no, depending on the tuning + * parameters. + */ +static inline int protocol_may_bind_quic(struct listener *l) +{ + if (global.tune.options & GTUNE_NO_QUIC) + return 0; + return 1; +} +#endif + +/* binds all listeners of all registered protocols. Returns a composition + * of ERR_NONE, ERR_RETRYABLE, ERR_FATAL. + */ +int protocol_bind_all(int verbose) +{ + struct protocol *proto; + struct listener *listener; + struct receiver *receiver; + char msg[1000]; + char *errmsg; + int err, lerr; + + err = 0; + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + list_for_each_entry(proto, &protocols, list) { + list_for_each_entry(receiver, &proto->receivers, proto_list) { + listener = LIST_ELEM(receiver, struct listener *, rx); +#ifdef USE_QUIC + if ((proto == &proto_quic4 || proto == &proto_quic6) && + !protocol_may_bind_quic(listener)) + continue; +#endif + + lerr = proto->fam->bind(receiver, &errmsg); + err |= lerr; + + /* errors are reported if <verbose> is set or if they are fatal */ + if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) { + struct proxy *px = listener->bind_conf->frontend; + + if (lerr & ERR_ALERT) + ha_alert("Binding [%s:%d] for %s %s: %s\n", + listener->bind_conf->file, listener->bind_conf->line, + proxy_type_str(px), px->id, errmsg); + else if (lerr & ERR_WARN) + ha_warning("Binding [%s:%d] for %s %s: %s\n", + listener->bind_conf->file, listener->bind_conf->line, + proxy_type_str(px), px->id, errmsg); + } + if (lerr != ERR_NONE) + ha_free(&errmsg); + + if (lerr & ERR_ABORT) + break; + + if (lerr & ~ERR_WARN) + continue; + + /* for now there's still always a listening function */ + BUG_ON(!proto->listen); + lerr = proto->listen(listener, msg, sizeof(msg)); + err |= lerr; + + if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) { + struct proxy *px = listener->bind_conf->frontend; + + if (lerr & ERR_ALERT) + ha_alert("Starting [%s:%d] for %s %s: %s\n", + listener->bind_conf->file, listener->bind_conf->line, + proxy_type_str(px), px->id, msg); + else if (lerr & ERR_WARN) + ha_warning("Starting [%s:%d] for %s %s: %s\n", + listener->bind_conf->file, listener->bind_conf->line, + proxy_type_str(px), px->id, msg); + } + if (lerr & ERR_ABORT) + break; + } + if (err & ERR_ABORT) + break; + } + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); + return err; +} + +/* unbinds all listeners of all registered protocols. They are also closed. + * This must be performed before calling exit() in order to get a chance to + * remove file-system based sockets and pipes. + * Returns a composition of ERR_NONE, ERR_RETRYABLE, ERR_FATAL, ERR_ABORT. + */ +int protocol_unbind_all(void) +{ + struct protocol *proto; + struct listener *listener; + int err; + + err = 0; + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + list_for_each_entry(proto, &protocols, list) { + list_for_each_entry(listener, &proto->receivers, rx.proto_list) + unbind_listener(listener); + } + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); + return err; +} + +/* stops all listeners of all registered protocols. This will normally catch + * every single listener, all protocols included. This is to be used during + * soft_stop() only. It does not return any error. + */ +void protocol_stop_now(void) +{ + struct protocol *proto; + struct listener *listener, *lback; + + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + list_for_each_entry(proto, &protocols, list) { + list_for_each_entry_safe(listener, lback, &proto->receivers, rx.proto_list) + stop_listener(listener, 0, 1, 0); + } + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); +} + +/* suspends all listeners of all registered protocols. This is typically + * used on SIG_TTOU to release all listening sockets for the time needed to + * try to bind a new process. The listeners enter LI_PAUSED or LI_ASSIGNED. + * It returns ERR_NONE, with ERR_FATAL on failure. + */ +int protocol_pause_all(void) +{ + struct protocol *proto; + struct listener *listener; + int err; + + err = 0; + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + list_for_each_entry(proto, &protocols, list) { + list_for_each_entry(listener, &proto->receivers, rx.proto_list) + if (!suspend_listener(listener, 0, 0)) + err |= ERR_FATAL; + } + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); + return err; +} + +/* resumes all listeners of all registered protocols. This is typically used on + * SIG_TTIN to re-enable listening sockets after a new process failed to bind. + * The listeners switch to LI_READY/LI_FULL. It returns ERR_NONE, with ERR_FATAL + * on failure. + */ +int protocol_resume_all(void) +{ + struct protocol *proto; + struct listener *listener; + int err; + + err = 0; + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + list_for_each_entry(proto, &protocols, list) { + list_for_each_entry(listener, &proto->receivers, rx.proto_list) + if (!resume_listener(listener, 0, 0)) + err |= ERR_FATAL; + } + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); + return err; +} + +/* enables all listeners of all registered protocols. This is intended to be + * used after a fork() to enable reading on all file descriptors. Returns + * composition of ERR_NONE. + */ +int protocol_enable_all(void) +{ + struct protocol *proto; + struct listener *listener; + + HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); + list_for_each_entry(proto, &protocols, list) { + list_for_each_entry(listener, &proto->receivers, rx.proto_list) + enable_listener(listener); + } + HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); + return ERR_NONE; +} + +/* + * Local variables: + * c-indent-level: 8 + * c-basic-offset: 8 + * End: + */ |