blob: 1806bed164141950af351eed2c95597805ccaaf7 [file] [log] [blame]
Willy Tarreaud1d54542012-09-12 22:58:11 +02001/*
2 * Protocol registration functions.
3 *
4 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreaua6e3be72016-08-10 18:24:48 +020013#include <sys/types.h>
Willy Tarreaub550d002015-02-20 16:53:25 +010014#include <sys/socket.h>
15
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020016#include <haproxy/api.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020017#include <haproxy/errors.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020018#include <haproxy/list.h>
Willy Tarreau94320852020-09-01 18:48:35 +020019#include <haproxy/listener.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020020#include <haproxy/protocol.h>
Willy Tarreaue91bff22020-09-02 11:11:43 +020021#include <haproxy/proxy.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020022#include <haproxy/tools.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020023
Willy Tarreaud1d54542012-09-12 22:58:11 +020024
25/* List head of all registered protocols */
26static struct list protocols = LIST_HEAD_INIT(protocols);
Willy Tarreauad6722e2021-04-10 17:38:05 +020027struct protocol *__protocol_by_family[AF_CUST_MAX][2][2] __read_mostly = { };
Willy Tarreaud1d54542012-09-12 22:58:11 +020028
Willy Tarreaudaacf362019-07-24 16:45:02 +020029/* This is the global spinlock we may need to register/unregister listeners or
30 * protocols. Its main purpose is in fact to serialize the rare stop/deinit()
31 * phases.
32 */
33__decl_spinlock(proto_lock);
34
Willy Tarreaud1d54542012-09-12 22:58:11 +020035/* Registers the protocol <proto> */
36void protocol_register(struct protocol *proto)
37{
Willy Tarreaudaacf362019-07-24 16:45:02 +020038 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau2b718102021-04-21 07:32:39 +020039 LIST_APPEND(&protocols, &proto->list);
Willy Tarreauf9ad06c2020-12-08 12:13:54 +010040 if (proto->fam->sock_domain >= 0 && proto->fam->sock_domain < AF_CUST_MAX)
41 __protocol_by_family[proto->fam->sock_domain]
Willy Tarreau910c64d2020-09-16 21:28:15 +020042 [proto->sock_type == SOCK_DGRAM]
43 [proto->ctrl_type == SOCK_DGRAM] = proto;
Willy Tarreaudaacf362019-07-24 16:45:02 +020044 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +020045}
46
47/* Unregisters the protocol <proto>. Note that all listeners must have
48 * previously been unbound.
49 */
50void protocol_unregister(struct protocol *proto)
51{
Willy Tarreaudaacf362019-07-24 16:45:02 +020052 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau2b718102021-04-21 07:32:39 +020053 LIST_DELETE(&proto->list);
Willy Tarreaud1d54542012-09-12 22:58:11 +020054 LIST_INIT(&proto->list);
Willy Tarreaudaacf362019-07-24 16:45:02 +020055 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +020056}
57
58/* binds all listeners of all registered protocols. Returns a composition
59 * of ERR_NONE, ERR_RETRYABLE, ERR_FATAL.
60 */
Willy Tarreaue91bff22020-09-02 11:11:43 +020061int protocol_bind_all(int verbose)
Willy Tarreaud1d54542012-09-12 22:58:11 +020062{
63 struct protocol *proto;
Willy Tarreau94320852020-09-01 18:48:35 +020064 struct listener *listener;
Willy Tarreaufc974882020-09-02 18:22:11 +020065 struct receiver *receiver;
Willy Tarreaue91bff22020-09-02 11:11:43 +020066 char msg[100];
Willy Tarreaufc974882020-09-02 18:22:11 +020067 char *errmsg;
Willy Tarreaue91bff22020-09-02 11:11:43 +020068 int err, lerr;
Willy Tarreaud1d54542012-09-12 22:58:11 +020069
70 err = 0;
Willy Tarreaudaacf362019-07-24 16:45:02 +020071 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +020072 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +020073 list_for_each_entry(receiver, &proto->receivers, proto_list) {
Willy Tarreaufc974882020-09-02 18:22:11 +020074 listener = LIST_ELEM(receiver, struct listener *, rx);
75
Willy Tarreau233ad282020-10-15 21:45:15 +020076 lerr = proto->fam->bind(receiver, &errmsg);
Willy Tarreaufc974882020-09-02 18:22:11 +020077 err |= lerr;
Willy Tarreaue91bff22020-09-02 11:11:43 +020078
79 /* errors are reported if <verbose> is set or if they are fatal */
80 if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) {
81 struct proxy *px = listener->bind_conf->frontend;
82
83 if (lerr & ERR_ALERT)
84 ha_alert("Starting %s %s: %s\n",
Willy Tarreaufc974882020-09-02 18:22:11 +020085 proxy_type_str(px), px->id, errmsg);
Willy Tarreaue91bff22020-09-02 11:11:43 +020086 else if (lerr & ERR_WARN)
87 ha_warning("Starting %s %s: %s\n",
Willy Tarreaufc974882020-09-02 18:22:11 +020088 proxy_type_str(px), px->id, errmsg);
Willy Tarreau61cfdf42021-02-20 10:46:51 +010089 ha_free(&errmsg);
Willy Tarreaue91bff22020-09-02 11:11:43 +020090 }
Willy Tarreaufc974882020-09-02 18:22:11 +020091 if (lerr & ERR_ABORT)
92 break;
Willy Tarreaue91bff22020-09-02 11:11:43 +020093
Willy Tarreaufc974882020-09-02 18:22:11 +020094 if (lerr & ~ERR_WARN)
95 continue;
96
97 /* for now there's still always a listening function */
98 BUG_ON(!proto->listen);
99 lerr = proto->listen(listener, msg, sizeof(msg));
Willy Tarreaue91bff22020-09-02 11:11:43 +0200100 err |= lerr;
Willy Tarreaufc974882020-09-02 18:22:11 +0200101
102 if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) {
103 struct proxy *px = listener->bind_conf->frontend;
104
105 if (lerr & ERR_ALERT)
106 ha_alert("Starting %s %s: %s\n",
107 proxy_type_str(px), px->id, msg);
108 else if (lerr & ERR_WARN)
109 ha_warning("Starting %s %s: %s\n",
110 proxy_type_str(px), px->id, msg);
111 }
Willy Tarreaue91bff22020-09-02 11:11:43 +0200112 if (lerr & ERR_ABORT)
Willy Tarreaud1d54542012-09-12 22:58:11 +0200113 break;
114 }
Willy Tarreaue91bff22020-09-02 11:11:43 +0200115 if (err & ERR_ABORT)
116 break;
Willy Tarreaud1d54542012-09-12 22:58:11 +0200117 }
Willy Tarreaudaacf362019-07-24 16:45:02 +0200118 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200119 return err;
120}
121
122/* unbinds all listeners of all registered protocols. They are also closed.
123 * This must be performed before calling exit() in order to get a chance to
124 * remove file-system based sockets and pipes.
125 * Returns a composition of ERR_NONE, ERR_RETRYABLE, ERR_FATAL, ERR_ABORT.
126 */
127int protocol_unbind_all(void)
128{
129 struct protocol *proto;
Willy Tarreauca212622020-09-02 10:31:31 +0200130 struct listener *listener;
Willy Tarreaud1d54542012-09-12 22:58:11 +0200131 int err;
132
133 err = 0;
Willy Tarreaudaacf362019-07-24 16:45:02 +0200134 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200135 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200136 list_for_each_entry(listener, &proto->receivers, rx.proto_list)
Willy Tarreauca212622020-09-02 10:31:31 +0200137 unbind_listener(listener);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200138 }
Willy Tarreaudaacf362019-07-24 16:45:02 +0200139 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200140 return err;
141}
142
Willy Tarreau02e85572020-10-07 16:50:49 +0200143/* stops all listeners of all registered protocols, except when the belong to a
144 * proxy configured with a grace time. This will normally catch every single
145 * listener, all protocols included, and the grace ones will have to be handled
146 * by the proxy stopping loop. This is to be used during soft_stop() only. It
147 * does not return any error.
148 */
149void protocol_stop_now(void)
150{
151 struct protocol *proto;
152 struct listener *listener, *lback;
153
154 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
155 list_for_each_entry(proto, &protocols, list) {
156 list_for_each_entry_safe(listener, lback, &proto->receivers, rx.proto_list)
157 if (!listener->bind_conf->frontend->grace)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200158 stop_listener(listener, 0, 1);
Willy Tarreau02e85572020-10-07 16:50:49 +0200159 }
160 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
161}
162
Willy Tarreau09819d12020-09-24 16:26:50 +0200163/* pauses all listeners of all registered protocols. This is typically
164 * used on SIG_TTOU to release all listening sockets for the time needed to
165 * try to bind a new process. The listeners enter LI_PAUSED. It returns
166 * ERR_NONE, with ERR_FATAL on failure.
167 */
168int protocol_pause_all(void)
169{
170 struct protocol *proto;
171 struct listener *listener;
172 int err;
173
174 err = 0;
175 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
176 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200177 list_for_each_entry(listener, &proto->receivers, rx.proto_list)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200178 if (!pause_listener(listener, 0))
Willy Tarreau09819d12020-09-24 16:26:50 +0200179 err |= ERR_FATAL;
180 }
181 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
182 return err;
183}
184
185/* resumes all listeners of all registered protocols. This is typically used on
186 * SIG_TTIN to re-enable listening sockets after a new process failed to bind.
187 * The listeners switch to LI_READY/LI_FULL. It returns ERR_NONE, with ERR_FATAL
188 * on failure.
189 */
190int protocol_resume_all(void)
191{
192 struct protocol *proto;
193 struct listener *listener;
194 int err;
195
196 err = 0;
197 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
198 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200199 list_for_each_entry(listener, &proto->receivers, rx.proto_list)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200200 if (!resume_listener(listener, 0))
Willy Tarreau09819d12020-09-24 16:26:50 +0200201 err |= ERR_FATAL;
202 }
203 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
204 return err;
205}
206
Willy Tarreaud1d54542012-09-12 22:58:11 +0200207/* enables all listeners of all registered protocols. This is intended to be
Willy Tarreau5b95ae62020-09-25 16:41:05 +0200208 * used after a fork() to enable reading on all file descriptors. Returns
209 * composition of ERR_NONE.
Willy Tarreaud1d54542012-09-12 22:58:11 +0200210 */
211int protocol_enable_all(void)
212{
213 struct protocol *proto;
Willy Tarreau5b95ae62020-09-25 16:41:05 +0200214 struct listener *listener;
Willy Tarreaud1d54542012-09-12 22:58:11 +0200215
Willy Tarreaudaacf362019-07-24 16:45:02 +0200216 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200217 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200218 list_for_each_entry(listener, &proto->receivers, rx.proto_list)
Willy Tarreau5b95ae62020-09-25 16:41:05 +0200219 enable_listener(listener);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200220 }
Willy Tarreaudaacf362019-07-24 16:45:02 +0200221 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau5b95ae62020-09-25 16:41:05 +0200222 return ERR_NONE;
Willy Tarreaud1d54542012-09-12 22:58:11 +0200223}
224
Willy Tarreaud1d54542012-09-12 22:58:11 +0200225/*
226 * Local variables:
227 * c-indent-level: 8
228 * c-basic-offset: 8
229 * End:
230 */