blob: cd23036b0bcec2521b3a35cd94d0524b4d56f425 [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 Tarreaue91bff22020-09-02 11:11:43 +020089 }
Aurelien DARRAGON8af08002023-02-07 15:51:58 +010090 if (lerr != ERR_NONE)
91 ha_free(&errmsg);
92
Willy Tarreaufc974882020-09-02 18:22:11 +020093 if (lerr & ERR_ABORT)
94 break;
Willy Tarreaue91bff22020-09-02 11:11:43 +020095
Willy Tarreaufc974882020-09-02 18:22:11 +020096 if (lerr & ~ERR_WARN)
97 continue;
98
99 /* for now there's still always a listening function */
100 BUG_ON(!proto->listen);
101 lerr = proto->listen(listener, msg, sizeof(msg));
Willy Tarreaue91bff22020-09-02 11:11:43 +0200102 err |= lerr;
Willy Tarreaufc974882020-09-02 18:22:11 +0200103
104 if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) {
105 struct proxy *px = listener->bind_conf->frontend;
106
107 if (lerr & ERR_ALERT)
108 ha_alert("Starting %s %s: %s\n",
109 proxy_type_str(px), px->id, msg);
110 else if (lerr & ERR_WARN)
111 ha_warning("Starting %s %s: %s\n",
112 proxy_type_str(px), px->id, msg);
113 }
Willy Tarreaue91bff22020-09-02 11:11:43 +0200114 if (lerr & ERR_ABORT)
Willy Tarreaud1d54542012-09-12 22:58:11 +0200115 break;
116 }
Willy Tarreaue91bff22020-09-02 11:11:43 +0200117 if (err & ERR_ABORT)
118 break;
Willy Tarreaud1d54542012-09-12 22:58:11 +0200119 }
Willy Tarreaudaacf362019-07-24 16:45:02 +0200120 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200121 return err;
122}
123
124/* unbinds all listeners of all registered protocols. They are also closed.
125 * This must be performed before calling exit() in order to get a chance to
126 * remove file-system based sockets and pipes.
127 * Returns a composition of ERR_NONE, ERR_RETRYABLE, ERR_FATAL, ERR_ABORT.
128 */
129int protocol_unbind_all(void)
130{
131 struct protocol *proto;
Willy Tarreauca212622020-09-02 10:31:31 +0200132 struct listener *listener;
Willy Tarreaud1d54542012-09-12 22:58:11 +0200133 int err;
134
135 err = 0;
Willy Tarreaudaacf362019-07-24 16:45:02 +0200136 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200137 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200138 list_for_each_entry(listener, &proto->receivers, rx.proto_list)
Willy Tarreauca212622020-09-02 10:31:31 +0200139 unbind_listener(listener);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200140 }
Willy Tarreaudaacf362019-07-24 16:45:02 +0200141 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200142 return err;
143}
144
Willy Tarreau02e85572020-10-07 16:50:49 +0200145/* stops all listeners of all registered protocols, except when the belong to a
146 * proxy configured with a grace time. This will normally catch every single
147 * listener, all protocols included, and the grace ones will have to be handled
148 * by the proxy stopping loop. This is to be used during soft_stop() only. It
149 * does not return any error.
150 */
151void protocol_stop_now(void)
152{
153 struct protocol *proto;
154 struct listener *listener, *lback;
155
156 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
157 list_for_each_entry(proto, &protocols, list) {
158 list_for_each_entry_safe(listener, lback, &proto->receivers, rx.proto_list)
159 if (!listener->bind_conf->frontend->grace)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200160 stop_listener(listener, 0, 1);
Willy Tarreau02e85572020-10-07 16:50:49 +0200161 }
162 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
163}
164
Willy Tarreau09819d12020-09-24 16:26:50 +0200165/* pauses all listeners of all registered protocols. This is typically
166 * used on SIG_TTOU to release all listening sockets for the time needed to
167 * try to bind a new process. The listeners enter LI_PAUSED. It returns
168 * ERR_NONE, with ERR_FATAL on failure.
169 */
170int protocol_pause_all(void)
171{
172 struct protocol *proto;
173 struct listener *listener;
174 int err;
175
176 err = 0;
177 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
178 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200179 list_for_each_entry(listener, &proto->receivers, rx.proto_list)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200180 if (!pause_listener(listener, 0))
Willy Tarreau09819d12020-09-24 16:26:50 +0200181 err |= ERR_FATAL;
182 }
183 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
184 return err;
185}
186
187/* resumes all listeners of all registered protocols. This is typically used on
188 * SIG_TTIN to re-enable listening sockets after a new process failed to bind.
189 * The listeners switch to LI_READY/LI_FULL. It returns ERR_NONE, with ERR_FATAL
190 * on failure.
191 */
192int protocol_resume_all(void)
193{
194 struct protocol *proto;
195 struct listener *listener;
196 int err;
197
198 err = 0;
199 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
200 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200201 list_for_each_entry(listener, &proto->receivers, rx.proto_list)
Aurelien DARRAGONa225fe82022-09-09 15:32:57 +0200202 if (!resume_listener(listener, 0))
Willy Tarreau09819d12020-09-24 16:26:50 +0200203 err |= ERR_FATAL;
204 }
205 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
206 return err;
207}
208
Willy Tarreaud1d54542012-09-12 22:58:11 +0200209/* enables all listeners of all registered protocols. This is intended to be
Willy Tarreau5b95ae62020-09-25 16:41:05 +0200210 * used after a fork() to enable reading on all file descriptors. Returns
211 * composition of ERR_NONE.
Willy Tarreaud1d54542012-09-12 22:58:11 +0200212 */
213int protocol_enable_all(void)
214{
215 struct protocol *proto;
Willy Tarreau5b95ae62020-09-25 16:41:05 +0200216 struct listener *listener;
Willy Tarreaud1d54542012-09-12 22:58:11 +0200217
Willy Tarreaudaacf362019-07-24 16:45:02 +0200218 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200219 list_for_each_entry(proto, &protocols, list) {
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200220 list_for_each_entry(listener, &proto->receivers, rx.proto_list)
Willy Tarreau5b95ae62020-09-25 16:41:05 +0200221 enable_listener(listener);
Willy Tarreaud1d54542012-09-12 22:58:11 +0200222 }
Willy Tarreaudaacf362019-07-24 16:45:02 +0200223 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau5b95ae62020-09-25 16:41:05 +0200224 return ERR_NONE;
Willy Tarreaud1d54542012-09-12 22:58:11 +0200225}
226
Willy Tarreaud1d54542012-09-12 22:58:11 +0200227/*
228 * Local variables:
229 * c-indent-level: 8
230 * c-basic-offset: 8
231 * End:
232 */