blob: f07170f297f1328e8d397129a5fe020e14b3d9e4 [file] [log] [blame]
Emeric Brun3835c0d2020-07-07 09:46:09 +02001/*
Willy Tarreau2b5e0d82020-09-16 21:58:52 +02002 * UDP protocol layer on top of AF_INET/AF_INET6
Emeric Brun3835c0d2020-07-07 09:46:09 +02003 *
4 * Copyright 2019 HAProxy Technologies, Frédéric Lécaille <flecaille@haproxy.com>
5 *
6 * Partial merge by Emeric Brun <ebrun@haproxy.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 *
13 */
14
15#include <ctype.h>
16#include <errno.h>
17#include <fcntl.h>
18#include <stdio.h>
19#include <stdlib.h>
20#include <string.h>
21#include <time.h>
22
23#include <sys/param.h>
24#include <sys/socket.h>
25#include <sys/types.h>
26
27#include <netinet/udp.h>
28#include <netinet/in.h>
29
30#include <haproxy/fd.h>
31#include <haproxy/listener.h>
32#include <haproxy/log.h>
33#include <haproxy/namespace.h>
34#include <haproxy/port_range.h>
35#include <haproxy/protocol.h>
36#include <haproxy/proto_udp.h>
37#include <haproxy/proxy.h>
38#include <haproxy/server.h>
Willy Tarreau18b7df72020-08-28 12:07:22 +020039#include <haproxy/sock.h>
Willy Tarreauf1725582020-08-28 15:30:11 +020040#include <haproxy/sock_inet.h>
Emeric Brun3835c0d2020-07-07 09:46:09 +020041#include <haproxy/task.h>
Willy Tarreauce65cbe2021-05-08 13:59:56 +020042#include <haproxy/tools.h>
Emeric Brun3835c0d2020-07-07 09:46:09 +020043
Emeric Brun3835c0d2020-07-07 09:46:09 +020044static int udp_bind_listener(struct listener *listener, char *errmsg, int errlen);
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +020045static void udp_enable_listener(struct listener *listener);
46static void udp_disable_listener(struct listener *listener);
Emeric Brun3835c0d2020-07-07 09:46:09 +020047
48/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaub9b2fd72020-12-08 14:13:11 +010049struct protocol proto_udp4 = {
Willy Tarreaub366c9a2020-12-08 14:54:20 +010050 .name = "udp4",
51
52 /* connection layer */
53 .ctrl_type = SOCK_DGRAM,
54 .listen = udp_bind_listener,
55 .enable = udp_enable_listener,
56 .disable = udp_disable_listener,
57 .add = default_add_listener,
58 .unbind = default_unbind_listener,
59 .suspend = default_suspend_listener,
60 .resume = default_resume_listener,
61
62 /* binding layer */
63 .rx_suspend = udp_suspend_receiver,
64 .rx_resume = udp_resume_receiver,
65
66 /* address family */
67 .fam = &proto_fam_inet4,
68
69 /* socket layer */
70 .sock_type = SOCK_DGRAM,
71 .sock_prot = IPPROTO_UDP,
72 .rx_enable = sock_enable,
73 .rx_disable = sock_disable,
74 .rx_unbind = sock_unbind,
75 .receivers = LIST_HEAD_INIT(proto_udp4.receivers),
76 .nb_receivers = 0,
Emeric Brun3835c0d2020-07-07 09:46:09 +020077};
78
79INITCALL1(STG_REGISTER, protocol_register, &proto_udp4);
80
81/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaub9b2fd72020-12-08 14:13:11 +010082struct protocol proto_udp6 = {
Willy Tarreaub366c9a2020-12-08 14:54:20 +010083 .name = "udp6",
84
85 /* connection layer */
86 .ctrl_type = SOCK_DGRAM,
87 .listen = udp_bind_listener,
88 .enable = udp_enable_listener,
89 .disable = udp_disable_listener,
90 .add = default_add_listener,
91 .unbind = default_unbind_listener,
92 .suspend = default_suspend_listener,
93 .resume = default_resume_listener,
94
95 /* binding layer */
96 .rx_suspend = udp_suspend_receiver,
97 .rx_resume = udp_resume_receiver,
98
99 /* address family */
100 .fam = &proto_fam_inet6,
101
102 /* socket layer */
103 .sock_type = SOCK_DGRAM,
104 .sock_prot = IPPROTO_UDP,
105 .rx_enable = sock_enable,
106 .rx_disable = sock_disable,
107 .rx_unbind = sock_unbind,
108 .receivers = LIST_HEAD_INIT(proto_udp6.receivers),
109 .nb_receivers = 0,
Emeric Brun3835c0d2020-07-07 09:46:09 +0200110};
111
112INITCALL1(STG_REGISTER, protocol_register, &proto_udp6);
113
Emeric Brun3835c0d2020-07-07 09:46:09 +0200114/* This function tries to bind a UDPv4/v6 listener. It may return a warning or
115 * an error message in <errmsg> if the message is at most <errlen> bytes long
116 * (including '\0'). Note that <errmsg> may be NULL if <errlen> is also zero.
117 * The return value is composed from ERR_ABORT, ERR_WARN,
118 * ERR_ALERT, ERR_RETRYABLE and ERR_FATAL. ERR_NONE indicates that everything
119 * was alright and that no message was returned. ERR_RETRYABLE means that an
120 * error occurred but that it may vanish after a retry (eg: port in use), and
121 * ERR_FATAL indicates a non-fixable error. ERR_WARN and ERR_ALERT do not alter
122 * the meaning of the error, but just indicate that a message is present which
123 * should be displayed with the respective level. Last, ERR_ABORT indicates
124 * that it's pointless to try to start other listeners. No error message is
125 * returned if errlen is NULL.
126 */
127int udp_bind_listener(struct listener *listener, char *errmsg, int errlen)
128{
Willy Tarreau2f7687d2020-09-01 16:23:29 +0200129 int err = ERR_NONE;
Willy Tarreau2f7687d2020-09-01 16:23:29 +0200130 char *msg = NULL;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200131
132 /* ensure we never return garbage */
133 if (errlen)
134 *errmsg = 0;
135
136 if (listener->state != LI_ASSIGNED)
137 return ERR_NONE; /* already bound */
138
Willy Tarreauad33acf2020-09-02 18:40:02 +0200139 if (!(listener->rx.flags & RX_F_BOUND)) {
140 msg = "receiving socket not bound";
Willy Tarreau2f7687d2020-09-01 16:23:29 +0200141 goto udp_return;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200142 }
143
Willy Tarreaua37b2442020-09-24 07:23:45 +0200144 listener_set_state(listener, LI_LISTEN);
Emeric Brun3835c0d2020-07-07 09:46:09 +0200145
Emeric Brun3835c0d2020-07-07 09:46:09 +0200146 udp_return:
147 if (msg && errlen) {
148 char pn[INET6_ADDRSTRLEN];
149
Willy Tarreau2f7687d2020-09-01 16:23:29 +0200150 addr_to_str(&listener->rx.addr, pn, sizeof(pn));
151 snprintf(errmsg, errlen, "%s [%s:%d]", msg, pn, get_host_port(&listener->rx.addr));
Emeric Brun3835c0d2020-07-07 09:46:09 +0200152 }
153 return err;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200154}
155
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200156/* Enable receipt of incoming connections for listener <l>. The receiver must
Willy Tarreaua4380b22020-11-04 13:59:04 +0100157 * still be valid.
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200158 */
159static void udp_enable_listener(struct listener *l)
160{
Willy Tarreaua4380b22020-11-04 13:59:04 +0100161 fd_want_recv_safe(l->rx.fd);
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200162}
163
164/* Disable receipt of incoming connections for listener <l>. The receiver must
Willy Tarreaua4380b22020-11-04 13:59:04 +0100165 * still be valid.
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200166 */
167static void udp_disable_listener(struct listener *l)
168{
Willy Tarreaua4380b22020-11-04 13:59:04 +0100169 fd_stop_recv(l->rx.fd);
Willy Tarreau5ddf1ce2020-09-25 19:27:39 +0200170}
171
Willy Tarreaucb66ea62020-09-25 17:12:32 +0200172/* Suspend a receiver. Returns < 0 in case of failure, 0 if the receiver
173 * was totally stopped, or > 0 if correctly suspended.
Willy Tarreaue122dc52020-10-07 19:55:15 +0200174 * The principle is a bit ugly but works well, at least on Linux: in order to
175 * suspend the receiver, we want it to stop receiving traffic, which means that
176 * the socket must be unhashed from the kernel's socket table. The simple way
177 * to do this is to connect to any address that is reachable and will not be
178 * used by regular traffic, and a great one is reconnecting to self.
Emeric Brun3835c0d2020-07-07 09:46:09 +0200179 */
Willy Tarreau29885f02020-12-08 18:05:16 +0100180int udp_suspend_receiver(struct receiver *rx)
Emeric Brun3835c0d2020-07-07 09:46:09 +0200181{
Willy Tarreaue122dc52020-10-07 19:55:15 +0200182 struct sockaddr_storage ss;
183 socklen_t len = sizeof(ss);
184
185 if (rx->fd < 0)
186 return 0;
187
Willy Tarreau59b5da42020-11-04 14:14:55 +0100188 /* we never do that with a shared FD otherwise we'd break it in the
189 * parent process and any possible subsequent worker inheriting it.
190 */
191 if (rx->flags & RX_F_INHERITED)
192 return -1;
193
Willy Tarreaue122dc52020-10-07 19:55:15 +0200194 if (getsockname(rx->fd, (struct sockaddr *)&ss, &len) < 0)
195 return -1;
196
197 if (connect(rx->fd, (struct sockaddr *)&ss, len) < 0)
198 return -1;
199
200 /* not necessary but may make debugging clearer */
201 fd_stop_recv(rx->fd);
202 return 1;
203}
204
205/* Resume a receiver. Returns < 0 in case of failure, 0 if the receiver
206 * was totally stopped, or > 0 if correctly suspended.
207 * The principle is to reverse the change above, we'll break the connection by
208 * connecting to AF_UNSPEC. The association breaks and the socket starts to
209 * receive from everywhere again.
210 */
Willy Tarreau29885f02020-12-08 18:05:16 +0100211int udp_resume_receiver(struct receiver *rx)
Willy Tarreaue122dc52020-10-07 19:55:15 +0200212{
Willy Tarreau2f6f3622020-10-14 10:50:41 +0200213 const struct sockaddr sa = { .sa_family = AF_UNSPEC };
Willy Tarreaue122dc52020-10-07 19:55:15 +0200214
215 if (rx->fd < 0)
216 return 0;
217
Willy Tarreau2f6f3622020-10-14 10:50:41 +0200218 if (connect(rx->fd, &sa, sizeof(sa)) < 0)
Willy Tarreaue122dc52020-10-07 19:55:15 +0200219 return -1;
220
221 fd_want_recv(rx->fd);
222 return 1;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200223}
224
225/*
226 * Local variables:
227 * c-indent-level: 8
228 * c-basic-offset: 8
229 * End:
230 */