blob: d369b08ccff898c2dcf86629ae7a3d6b9b1983fe [file] [log] [blame]
Emeric Brun2b920a12010-09-23 18:30:22 +02001/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02002 * Peer synchro management.
Emeric Brun2b920a12010-09-23 18:30:22 +02003 *
4 * Copyright 2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
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
13#include <errno.h>
14#include <fcntl.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18
19#include <sys/socket.h>
20#include <sys/stat.h>
21#include <sys/types.h>
22
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020023#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020024#include <haproxy/applet.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020025#include <haproxy/channel.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020026#include <haproxy/cli.h>
Willy Tarreau3afc4c42020-06-03 18:23:19 +020027#include <haproxy/dict.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020028#include <haproxy/errors.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020029#include <haproxy/fd.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020030#include <haproxy/frontend.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020031#include <haproxy/net_helper.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020032#include <haproxy/obj_type-t.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020033#include <haproxy/peers.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020034#include <haproxy/proxy.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020035#include <haproxy/session-t.h>
Willy Tarreau3727a8a2020-06-04 17:37:26 +020036#include <haproxy/signal.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020037#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020038#include <haproxy/stick_table.h>
39#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020040#include <haproxy/stream_interface.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020041#include <haproxy/task.h>
42#include <haproxy/thread.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020043#include <haproxy/time.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020044#include <haproxy/tools.h>
Frédéric Lécaille94571512020-11-10 16:18:03 +010045#include <haproxy/trace.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020046
Emeric Brun2b920a12010-09-23 18:30:22 +020047
48/*******************************/
49/* Current peer learning state */
50/*******************************/
51
52/******************************/
Emeric Brunb3971ab2015-05-12 18:49:09 +020053/* Current peers section resync state */
Emeric Brun2b920a12010-09-23 18:30:22 +020054/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010055#define PEERS_F_RESYNC_LOCAL 0x00000001 /* Learn from local finished or no more needed */
56#define PEERS_F_RESYNC_REMOTE 0x00000002 /* Learn from remote finished or no more needed */
57#define PEERS_F_RESYNC_ASSIGN 0x00000004 /* A peer was assigned to learn our lesson */
58#define PEERS_F_RESYNC_PROCESS 0x00000008 /* The assigned peer was requested for resync */
59#define PEERS_F_DONOTSTOP 0x00010000 /* Main table sync task block process during soft stop
60 to push data to new process */
Emeric Brun2b920a12010-09-23 18:30:22 +020061
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010062#define PEERS_RESYNC_STATEMASK (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
63#define PEERS_RESYNC_FROMLOCAL 0x00000000
64#define PEERS_RESYNC_FROMREMOTE PEERS_F_RESYNC_LOCAL
65#define PEERS_RESYNC_FINISHED (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
Emeric Brunb3971ab2015-05-12 18:49:09 +020066
67/***********************************/
68/* Current shared table sync state */
69/***********************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010070#define SHTABLE_F_TEACH_STAGE1 0x00000001 /* Teach state 1 complete */
71#define SHTABLE_F_TEACH_STAGE2 0x00000002 /* Teach state 2 complete */
Emeric Brun2b920a12010-09-23 18:30:22 +020072
73/******************************/
74/* Remote peer teaching state */
75/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010076#define PEER_F_TEACH_PROCESS 0x00000001 /* Teach a lesson to current peer */
77#define PEER_F_TEACH_FINISHED 0x00000008 /* Teach conclude, (wait for confirm) */
78#define PEER_F_TEACH_COMPLETE 0x00000010 /* All that we know already taught to current peer, used only for a local peer */
79#define PEER_F_LEARN_ASSIGN 0x00000100 /* Current peer was assigned for a lesson */
80#define PEER_F_LEARN_NOTUP2DATE 0x00000200 /* Learn from peer finished but peer is not up to date */
81#define PEER_F_ALIVE 0x20000000 /* Used to flag a peer a alive. */
82#define PEER_F_HEARTBEAT 0x40000000 /* Heartbeat message to send. */
83#define PEER_F_DWNGRD 0x80000000 /* When this flag is enabled, we must downgrade the supported version announced during peer sessions. */
Emeric Brun2b920a12010-09-23 18:30:22 +020084
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010085#define PEER_TEACH_RESET ~(PEER_F_TEACH_PROCESS|PEER_F_TEACH_FINISHED) /* PEER_F_TEACH_COMPLETE should never be reset */
86#define PEER_LEARN_RESET ~(PEER_F_LEARN_ASSIGN|PEER_F_LEARN_NOTUP2DATE)
Emeric Brun2b920a12010-09-23 18:30:22 +020087
Frédéric Lécaille54bff832019-03-26 10:25:20 +010088#define PEER_RESYNC_TIMEOUT 5000 /* 5 seconds */
89#define PEER_RECONNECT_TIMEOUT 5000 /* 5 seconds */
Frédéric Lécaille645635d2019-02-11 17:49:39 +010090#define PEER_HEARTBEAT_TIMEOUT 3000 /* 3 seconds */
91
Emeric Brunb3971ab2015-05-12 18:49:09 +020092/*****************************/
93/* Sync message class */
94/*****************************/
95enum {
96 PEER_MSG_CLASS_CONTROL = 0,
97 PEER_MSG_CLASS_ERROR,
98 PEER_MSG_CLASS_STICKTABLE = 10,
99 PEER_MSG_CLASS_RESERVED = 255,
100};
101
102/*****************************/
103/* control message types */
104/*****************************/
105enum {
106 PEER_MSG_CTRL_RESYNCREQ = 0,
107 PEER_MSG_CTRL_RESYNCFINISHED,
108 PEER_MSG_CTRL_RESYNCPARTIAL,
109 PEER_MSG_CTRL_RESYNCCONFIRM,
Frédéric Lécaille645635d2019-02-11 17:49:39 +0100110 PEER_MSG_CTRL_HEARTBEAT,
Emeric Brunb3971ab2015-05-12 18:49:09 +0200111};
112
113/*****************************/
114/* error message types */
115/*****************************/
116enum {
117 PEER_MSG_ERR_PROTOCOL = 0,
118 PEER_MSG_ERR_SIZELIMIT,
119};
120
Emeric Brun530ba382020-06-02 11:17:42 +0200121/* network key types;
122 * network types were directly and mistakenly
123 * mapped on sample types, to keep backward
124 * compatiblitiy we keep those values but
125 * we now use a internal/network mapping
126 * to avoid further mistakes adding or
127 * modifying internals types
128 */
129enum {
130 PEER_KT_ANY = 0, /* any type */
131 PEER_KT_RESV1, /* UNUSED */
132 PEER_KT_SINT, /* signed 64bits integer type */
133 PEER_KT_RESV3, /* UNUSED */
134 PEER_KT_IPV4, /* ipv4 type */
135 PEER_KT_IPV6, /* ipv6 type */
136 PEER_KT_STR, /* char string type */
137 PEER_KT_BIN, /* buffer type */
138 PEER_KT_TYPES /* number of types, must always be last */
139};
140
141/* Map used to retrieve network type from internal type
142 * Note: Undeclared mapping maps entry to PEER_KT_ANY == 0
143 */
144static int peer_net_key_type[SMP_TYPES] = {
145 [SMP_T_SINT] = PEER_KT_SINT,
146 [SMP_T_IPV4] = PEER_KT_IPV4,
147 [SMP_T_IPV6] = PEER_KT_IPV6,
148 [SMP_T_STR] = PEER_KT_STR,
149 [SMP_T_BIN] = PEER_KT_BIN,
150};
151
152/* Map used to retrieve internal type from external type
153 * Note: Undeclared mapping maps entry to SMP_T_ANY == 0
154 */
155static int peer_int_key_type[PEER_KT_TYPES] = {
156 [PEER_KT_SINT] = SMP_T_SINT,
157 [PEER_KT_IPV4] = SMP_T_IPV4,
158 [PEER_KT_IPV6] = SMP_T_IPV6,
159 [PEER_KT_STR] = SMP_T_STR,
160 [PEER_KT_BIN] = SMP_T_BIN,
161};
162
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100163/*
164 * Parameters used by functions to build peer protocol messages. */
165struct peer_prep_params {
166 struct {
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100167 struct peer *peer;
168 } hello;
169 struct {
170 unsigned int st1;
171 } error_status;
172 struct {
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100173 struct stksess *stksess;
174 struct shared_table *shared_table;
175 unsigned int updateid;
176 int use_identifier;
177 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200178 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100179 } updt;
180 struct {
181 struct shared_table *shared_table;
182 } swtch;
183 struct {
184 struct shared_table *shared_table;
185 } ack;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100186 struct {
187 unsigned char head[2];
188 } control;
189 struct {
190 unsigned char head[2];
191 } error;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100192};
Emeric Brunb3971ab2015-05-12 18:49:09 +0200193
194/*******************************/
195/* stick table sync mesg types */
196/* Note: ids >= 128 contains */
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500197/* id message contains data */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200198/*******************************/
Olivier Houchard33992262018-10-16 18:49:26 +0200199#define PEER_MSG_STKT_UPDATE 0x80
200#define PEER_MSG_STKT_INCUPDATE 0x81
201#define PEER_MSG_STKT_DEFINE 0x82
202#define PEER_MSG_STKT_SWITCH 0x83
203#define PEER_MSG_STKT_ACK 0x84
204#define PEER_MSG_STKT_UPDATE_TIMED 0x85
205#define PEER_MSG_STKT_INCUPDATE_TIMED 0x86
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +0200206/* All the stick-table message identifiers abova have the #7 bit set */
207#define PEER_MSG_STKT_BIT 7
208#define PEER_MSG_STKT_BIT_MASK (1 << PEER_MSG_STKT_BIT)
Emeric Brun2b920a12010-09-23 18:30:22 +0200209
Frédéric Lécaille39143342019-05-24 14:32:27 +0200210/* The maximum length of an encoded data length. */
211#define PEER_MSG_ENC_LENGTH_MAXLEN 5
212
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200213/* Minimum 64-bits value encoded with 2 bytes */
214#define PEER_ENC_2BYTES_MIN 0xf0 /* 0xf0 (or 240) */
215/* 3 bytes */
216#define PEER_ENC_3BYTES_MIN ((1ULL << 11) | PEER_ENC_2BYTES_MIN) /* 0x8f0 (or 2288) */
217/* 4 bytes */
218#define PEER_ENC_4BYTES_MIN ((1ULL << 18) | PEER_ENC_3BYTES_MIN) /* 0x408f0 (or 264432) */
219/* 5 bytes */
220#define PEER_ENC_5BYTES_MIN ((1ULL << 25) | PEER_ENC_4BYTES_MIN) /* 0x20408f0 (or 33818864) */
221/* 6 bytes */
222#define PEER_ENC_6BYTES_MIN ((1ULL << 32) | PEER_ENC_5BYTES_MIN) /* 0x1020408f0 (or 4328786160) */
223/* 7 bytes */
224#define PEER_ENC_7BYTES_MIN ((1ULL << 39) | PEER_ENC_6BYTES_MIN) /* 0x81020408f0 (or 554084600048) */
225/* 8 bytes */
226#define PEER_ENC_8BYTES_MIN ((1ULL << 46) | PEER_ENC_7BYTES_MIN) /* 0x4081020408f0 (or 70922828777712) */
227/* 9 bytes */
228#define PEER_ENC_9BYTES_MIN ((1ULL << 53) | PEER_ENC_8BYTES_MIN) /* 0x204081020408f0 (or 9078122083518704) */
229/* 10 bytes */
230#define PEER_ENC_10BYTES_MIN ((1ULL << 60) | PEER_ENC_9BYTES_MIN) /* 0x10204081020408f0 (or 1161999626690365680) */
231
232/* #7 bit used to detect the last byte to be encoded */
233#define PEER_ENC_STOP_BIT 7
234/* The byte minimum value with #7 bit set */
235#define PEER_ENC_STOP_BYTE (1 << PEER_ENC_STOP_BIT)
236/* The left most number of bits set for PEER_ENC_2BYTES_MIN */
237#define PEER_ENC_2BYTES_MIN_BITS 4
238
Frédéric Lécaille39143342019-05-24 14:32:27 +0200239#define PEER_MSG_HEADER_LEN 2
240
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200241#define PEER_STKT_CACHE_MAX_ENTRIES 128
242
Emeric Brun2b920a12010-09-23 18:30:22 +0200243/**********************************/
244/* Peer Session IO handler states */
245/**********************************/
246
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100247enum {
248 PEER_SESS_ST_ACCEPT = 0, /* Initial state for session create by an accept, must be zero! */
249 PEER_SESS_ST_GETVERSION, /* Validate supported protocol version */
250 PEER_SESS_ST_GETHOST, /* Validate host ID correspond to local host id */
251 PEER_SESS_ST_GETPEER, /* Validate peer ID correspond to a known remote peer id */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100252 /* after this point, data were possibly exchanged */
253 PEER_SESS_ST_SENDSUCCESS, /* Send ret code 200 (success) and wait for message */
254 PEER_SESS_ST_CONNECT, /* Initial state for session create on a connect, push presentation into buffer */
255 PEER_SESS_ST_GETSTATUS, /* Wait for the welcome message */
256 PEER_SESS_ST_WAITMSG, /* Wait for data messages */
257 PEER_SESS_ST_EXIT, /* Exit with status code */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200258 PEER_SESS_ST_ERRPROTO, /* Send error proto message before exit */
259 PEER_SESS_ST_ERRSIZE, /* Send error size message before exit */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100260 PEER_SESS_ST_END, /* Killed session */
261};
Emeric Brun2b920a12010-09-23 18:30:22 +0200262
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100263/***************************************************/
264/* Peer Session status code - part of the protocol */
265/***************************************************/
Emeric Brun2b920a12010-09-23 18:30:22 +0200266
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100267#define PEER_SESS_SC_CONNECTCODE 100 /* connect in progress */
268#define PEER_SESS_SC_CONNECTEDCODE 110 /* tcp connect success */
Emeric Brun2b920a12010-09-23 18:30:22 +0200269
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100270#define PEER_SESS_SC_SUCCESSCODE 200 /* accept or connect successful */
Emeric Brun2b920a12010-09-23 18:30:22 +0200271
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100272#define PEER_SESS_SC_TRYAGAIN 300 /* try again later */
Emeric Brun2b920a12010-09-23 18:30:22 +0200273
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100274#define PEER_SESS_SC_ERRPROTO 501 /* error protocol */
275#define PEER_SESS_SC_ERRVERSION 502 /* unknown protocol version */
276#define PEER_SESS_SC_ERRHOST 503 /* bad host name */
277#define PEER_SESS_SC_ERRPEER 504 /* unknown peer */
Emeric Brun2b920a12010-09-23 18:30:22 +0200278
279#define PEER_SESSION_PROTO_NAME "HAProxyS"
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200280#define PEER_MAJOR_VER 2
281#define PEER_MINOR_VER 1
282#define PEER_DWNGRD_MINOR_VER 0
Emeric Brun2b920a12010-09-23 18:30:22 +0200283
Willy Tarreau6254a922019-01-29 17:45:23 +0100284static size_t proto_len = sizeof(PEER_SESSION_PROTO_NAME) - 1;
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200285struct peers *cfg_peers = NULL;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200286static void peer_session_forceshutdown(struct peer *peer);
Emeric Brun2b920a12010-09-23 18:30:22 +0200287
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200288static struct ebpt_node *dcache_tx_insert(struct dcache *dc,
289 struct dcache_tx_entry *i);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200290static inline void flush_dcache(struct peer *peer);
291
Frédéric Lécaille94571512020-11-10 16:18:03 +0100292/* trace source and events */
293static void peers_trace(enum trace_level level, uint64_t mask,
294 const struct trace_source *src,
295 const struct ist where, const struct ist func,
296 const void *a1, const void *a2, const void *a3, const void *a4);
297
298static const struct trace_event peers_trace_events[] = {
299#define PEERS_EV_UPDTMSG (1 << 0)
300 { .mask = PEERS_EV_UPDTMSG, .name = "updtmsg", .desc = "update message received" },
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +0100301#define PEERS_EV_ACKMSG (1 << 1)
302 { .mask = PEERS_EV_ACKMSG, .name = "ackmsg", .desc = "ack message received" },
303#define PEERS_EV_SWTCMSG (1 << 2)
304 { .mask = PEERS_EV_SWTCMSG, .name = "swtcmsg", .desc = "switch message received" },
305#define PEERS_EV_DEFMSG (1 << 3)
306 { .mask = PEERS_EV_DEFMSG, .name = "defmsg", .desc = "definition message received" },
307#define PEERS_EV_CTRLMSG (1 << 4)
308 { .mask = PEERS_EV_CTRLMSG, .name = "ctrlmsg", .desc = "control message sent/received" },
309#define PEERS_EV_SESSREL (1 << 5)
310 { .mask = PEERS_EV_SESSREL, .name = "sessrl", .desc = "peer session releasing" },
311#define PEERS_EV_PROTOERR (1 << 6)
312 { .mask = PEERS_EV_PROTOERR, .name = "protoerr", .desc = "protocol error" },
Frédéric Lécaille94571512020-11-10 16:18:03 +0100313};
314
315static const struct name_desc peers_trace_lockon_args[4] = {
316 /* arg1 */ { /* already used by the connection */ },
317 /* arg2 */ { .name="peers", .desc="Peers protocol" },
318 /* arg3 */ { },
319 /* arg4 */ { }
320};
321
322static const struct name_desc peers_trace_decoding[] = {
323#define PEERS_VERB_CLEAN 1
324 { .name="clean", .desc="only user-friendly stuff, generally suitable for level \"user\"" },
325 { /* end */ }
326};
327
328
329struct trace_source trace_peers = {
330 .name = IST("peers"),
331 .desc = "Peers protocol",
332 .arg_def = TRC_ARG1_CONN, /* TRACE()'s first argument is always a connection */
333 .default_cb = peers_trace,
334 .known_events = peers_trace_events,
335 .lockon_args = peers_trace_lockon_args,
336 .decoding = peers_trace_decoding,
337 .report_events = ~0, /* report everything by default */
338};
339
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +0100340/* Return peer control message types as strings (only for debugging purpose). */
341static inline char *ctrl_msg_type_str(unsigned int type)
342{
343 switch (type) {
344 case PEER_MSG_CTRL_RESYNCREQ:
345 return "RESYNCREQ";
346 case PEER_MSG_CTRL_RESYNCFINISHED:
347 return "RESYNCFINISHED";
348 case PEER_MSG_CTRL_RESYNCPARTIAL:
349 return "RESYNCPARTIAL";
350 case PEER_MSG_CTRL_RESYNCCONFIRM:
351 return "RESYNCCONFIRM";
352 case PEER_MSG_CTRL_HEARTBEAT:
353 return "HEARTBEAT";
354 default:
355 return "???";
356 }
357}
358
Frédéric Lécaille94571512020-11-10 16:18:03 +0100359#define TRACE_SOURCE &trace_peers
360INITCALL1(STG_REGISTER, trace_register_source, TRACE_SOURCE);
361
362static void peers_trace(enum trace_level level, uint64_t mask,
363 const struct trace_source *src,
364 const struct ist where, const struct ist func,
365 const void *a1, const void *a2, const void *a3, const void *a4)
366{
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +0100367 if (mask & (PEERS_EV_UPDTMSG|PEERS_EV_ACKMSG|PEERS_EV_SWTCMSG)) {
Frédéric Lécaille94571512020-11-10 16:18:03 +0100368 if (a2) {
369 const struct peer *peer = a2;
370
371 chunk_appendf(&trace_buf, " peer=%s", peer->id);
372 }
373 if (a3) {
374 const char *p = a3;
375
376 chunk_appendf(&trace_buf, " @%p", p);
377 }
378 if (a4) {
379 const size_t *val = a4;
380
381 chunk_appendf(&trace_buf, " %llu", (unsigned long long)*val);
382 }
383 }
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +0100384
385 if (mask & PEERS_EV_DEFMSG) {
386 if (a2) {
387 const struct peer *peer = a2;
388
389 chunk_appendf(&trace_buf, " peer=%s", peer->id);
390 }
391 if (a3) {
392 const char *p = a3;
393
394 chunk_appendf(&trace_buf, " @%p", p);
395 }
396 if (a4) {
397 const int *val = a4;
398
399 chunk_appendf(&trace_buf, " %d", *val);
400 }
401 }
402
403 if (mask & PEERS_EV_CTRLMSG) {
404 if (a2) {
405 const unsigned char *ctrl_msg_type = a2;
406
407 chunk_appendf(&trace_buf, " %s", ctrl_msg_type_str(*ctrl_msg_type));
408
409 }
410 if (a3) {
411 const char *local_peer = a3;
412
413 chunk_appendf(&trace_buf, " %s", local_peer);
414 }
415
416 if (a4) {
417 const char *remote_peer = a4;
418
419 chunk_appendf(&trace_buf, " -> %s", remote_peer);
420 }
421 }
422
423 if (mask & (PEERS_EV_SESSREL|PEERS_EV_PROTOERR)) {
424 if (a2) {
425 const struct peer *peer = a2;
426 struct peers *peers = NULL;
427
Frédéric Lécaille707a1f52021-01-17 13:08:39 +0100428 if (peer && peer->appctx) {
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +0100429 struct stream_interface *si;
430
431 si = peer->appctx->owner;
432 if (si) {
433 struct stream *s = si_strm(si);
434
435 peers = strm_fe(s)->parent;
436 }
437 }
438
439 if (peers)
440 chunk_appendf(&trace_buf, " %s", peers->local->id);
441 if (peer)
442 chunk_appendf(&trace_buf, " -> %s", peer->id);
443 }
444
445 if (a3) {
446 const int *prev_state = a3;
447
448 chunk_appendf(&trace_buf, " prev_state=%d\n", *prev_state);
449 }
450 }
Frédéric Lécaille94571512020-11-10 16:18:03 +0100451}
452
Frédéric Lécaille95679dc2019-04-15 10:25:27 +0200453static const char *statuscode_str(int statuscode)
454{
455 switch (statuscode) {
456 case PEER_SESS_SC_CONNECTCODE:
457 return "CONN";
458 case PEER_SESS_SC_CONNECTEDCODE:
459 return "HSHK";
460 case PEER_SESS_SC_SUCCESSCODE:
461 return "ESTA";
462 case PEER_SESS_SC_TRYAGAIN:
463 return "RETR";
464 case PEER_SESS_SC_ERRPROTO:
465 return "PROT";
466 case PEER_SESS_SC_ERRVERSION:
467 return "VERS";
468 case PEER_SESS_SC_ERRHOST:
469 return "NAME";
470 case PEER_SESS_SC_ERRPEER:
471 return "UNKN";
472 default:
473 return "NONE";
474 }
475}
476
Emeric Brun18928af2017-03-29 16:32:53 +0200477/* This function encode an uint64 to 'dynamic' length format.
478 The encoded value is written at address *str, and the
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500479 caller must assure that size after *str is large enough.
Emeric Brun18928af2017-03-29 16:32:53 +0200480 At return, the *str is set at the next Byte after then
481 encoded integer. The function returns then length of the
482 encoded integer in Bytes */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200483int intencode(uint64_t i, char **str) {
484 int idx = 0;
485 unsigned char *msg;
486
Emeric Brunb3971ab2015-05-12 18:49:09 +0200487 msg = (unsigned char *)*str;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200488 if (i < PEER_ENC_2BYTES_MIN) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200489 msg[0] = (unsigned char)i;
490 *str = (char *)&msg[idx+1];
491 return (idx+1);
492 }
493
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200494 msg[idx] =(unsigned char)i | PEER_ENC_2BYTES_MIN;
495 i = (i - PEER_ENC_2BYTES_MIN) >> PEER_ENC_2BYTES_MIN_BITS;
496 while (i >= PEER_ENC_STOP_BYTE) {
497 msg[++idx] = (unsigned char)i | PEER_ENC_STOP_BYTE;
498 i = (i - PEER_ENC_STOP_BYTE) >> PEER_ENC_STOP_BIT;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200499 }
500 msg[++idx] = (unsigned char)i;
501 *str = (char *)&msg[idx+1];
502 return (idx+1);
503}
504
505
506/* This function returns the decoded integer or 0
507 if decode failed
508 *str point on the beginning of the integer to decode
509 at the end of decoding *str point on the end of the
510 encoded integer or to null if end is reached */
Emeric Brun18928af2017-03-29 16:32:53 +0200511uint64_t intdecode(char **str, char *end)
512{
Emeric Brunb3971ab2015-05-12 18:49:09 +0200513 unsigned char *msg;
Emeric Brun18928af2017-03-29 16:32:53 +0200514 uint64_t i;
515 int shift;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200516
517 if (!*str)
518 return 0;
519
520 msg = (unsigned char *)*str;
Emeric Brun18928af2017-03-29 16:32:53 +0200521 if (msg >= (unsigned char *)end)
522 goto fail;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200523
Emeric Brun18928af2017-03-29 16:32:53 +0200524 i = *(msg++);
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200525 if (i >= PEER_ENC_2BYTES_MIN) {
526 shift = PEER_ENC_2BYTES_MIN_BITS;
Emeric Brun18928af2017-03-29 16:32:53 +0200527 do {
528 if (msg >= (unsigned char *)end)
529 goto fail;
530 i += (uint64_t)*msg << shift;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200531 shift += PEER_ENC_STOP_BIT;
532 } while (*(msg++) >= PEER_ENC_STOP_BYTE);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200533 }
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100534 *str = (char *)msg;
535 return i;
Emeric Brun18928af2017-03-29 16:32:53 +0200536
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100537 fail:
538 *str = NULL;
539 return 0;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200540}
Emeric Brun2b920a12010-09-23 18:30:22 +0200541
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100542/*
543 * Build a "hello" peer protocol message.
544 * Return the number of written bytes written to build this messages if succeeded,
545 * 0 if not.
546 */
547static int peer_prepare_hellomsg(char *msg, size_t size, struct peer_prep_params *p)
548{
549 int min_ver, ret;
550 struct peer *peer;
551
552 peer = p->hello.peer;
553 min_ver = (peer->flags & PEER_F_DWNGRD) ? PEER_DWNGRD_MINOR_VER : PEER_MINOR_VER;
554 /* Prepare headers */
555 ret = snprintf(msg, size, PEER_SESSION_PROTO_NAME " %u.%u\n%s\n%s %d %d\n",
556 PEER_MAJOR_VER, min_ver, peer->id, localpeer, (int)getpid(), relative_pid);
557 if (ret >= size)
558 return 0;
559
560 return ret;
561}
562
563/*
564 * Build a "handshake succeeded" status message.
565 * Return the number of written bytes written to build this messages if succeeded,
566 * 0 if not.
567 */
568static int peer_prepare_status_successmsg(char *msg, size_t size, struct peer_prep_params *p)
569{
570 int ret;
571
572 ret = snprintf(msg, size, "%d\n", PEER_SESS_SC_SUCCESSCODE);
573 if (ret >= size)
574 return 0;
575
576 return ret;
577}
578
579/*
580 * Build an error status message.
581 * Return the number of written bytes written to build this messages if succeeded,
582 * 0 if not.
583 */
584static int peer_prepare_status_errormsg(char *msg, size_t size, struct peer_prep_params *p)
585{
586 int ret;
587 unsigned int st1;
588
589 st1 = p->error_status.st1;
590 ret = snprintf(msg, size, "%d\n", st1);
591 if (ret >= size)
592 return 0;
593
594 return ret;
595}
596
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200597/* Set the stick-table UPDATE message type byte at <msg_type> address,
598 * depending on <use_identifier> and <use_timed> boolean parameters.
599 * Always successful.
600 */
601static inline void peer_set_update_msg_type(char *msg_type, int use_identifier, int use_timed)
602{
603 if (use_timed) {
604 if (use_identifier)
605 *msg_type = PEER_MSG_STKT_UPDATE_TIMED;
606 else
607 *msg_type = PEER_MSG_STKT_INCUPDATE_TIMED;
608 }
609 else {
610 if (use_identifier)
611 *msg_type = PEER_MSG_STKT_UPDATE;
612 else
613 *msg_type = PEER_MSG_STKT_INCUPDATE;
614 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200615}
Emeric Brun2b920a12010-09-23 18:30:22 +0200616/*
Emeric Brunb3971ab2015-05-12 18:49:09 +0200617 * This prepare the data update message on the stick session <ts>, <st> is the considered
618 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800619 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200620 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
621 * check size)
Emeric Brun2b920a12010-09-23 18:30:22 +0200622 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100623static int peer_prepare_updatemsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brun2b920a12010-09-23 18:30:22 +0200624{
625 uint32_t netinteger;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200626 unsigned short datalen;
627 char *cursor, *datamsg;
Emeric Brun94900952015-06-11 18:25:54 +0200628 unsigned int data_type;
629 void *data_ptr;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100630 struct stksess *ts;
631 struct shared_table *st;
632 unsigned int updateid;
633 int use_identifier;
634 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200635 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100636
637 ts = p->updt.stksess;
638 st = p->updt.shared_table;
639 updateid = p->updt.updateid;
640 use_identifier = p->updt.use_identifier;
641 use_timed = p->updt.use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200642 peer = p->updt.peer;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200643
Frédéric Lécaille0e8db972019-05-24 14:34:34 +0200644 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200645
Emeric Brun2b920a12010-09-23 18:30:22 +0200646 /* construct message */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200647
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500648 /* check if we need to send the update identifier */
Emeric Brun819fc6f2017-06-13 19:37:32 +0200649 if (!st->last_pushed || updateid < st->last_pushed || ((updateid - st->last_pushed) != 1)) {
Emeric Bruna6a09982015-09-22 15:34:19 +0200650 use_identifier = 1;
Emeric Brun2b920a12010-09-23 18:30:22 +0200651 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200652
653 /* encode update identifier if needed */
654 if (use_identifier) {
Emeric Brun819fc6f2017-06-13 19:37:32 +0200655 netinteger = htonl(updateid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200656 memcpy(cursor, &netinteger, sizeof(netinteger));
657 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200658 }
659
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200660 if (use_timed) {
661 netinteger = htonl(tick_remain(now_ms, ts->expire));
662 memcpy(cursor, &netinteger, sizeof(netinteger));
663 cursor += sizeof(netinteger);
664 }
665
Emeric Brunb3971ab2015-05-12 18:49:09 +0200666 /* encode the key */
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200667 if (st->table->type == SMP_T_STR) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200668 int stlen = strlen((char *)ts->key.key);
669
Emeric Brunb3971ab2015-05-12 18:49:09 +0200670 intencode(stlen, &cursor);
671 memcpy(cursor, ts->key.key, stlen);
672 cursor += stlen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200673 }
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200674 else if (st->table->type == SMP_T_SINT) {
Willy Tarreau6cde5d82020-02-25 09:41:22 +0100675 netinteger = htonl(read_u32(ts->key.key));
Emeric Brunb3971ab2015-05-12 18:49:09 +0200676 memcpy(cursor, &netinteger, sizeof(netinteger));
677 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200678 }
679 else {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200680 memcpy(cursor, ts->key.key, st->table->key_size);
681 cursor += st->table->key_size;
Emeric Brun2b920a12010-09-23 18:30:22 +0200682 }
683
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100684 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200685 /* encode values */
Emeric Brun94900952015-06-11 18:25:54 +0200686 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200687
Emeric Brun94900952015-06-11 18:25:54 +0200688 data_ptr = stktable_data_ptr(st->table, ts, data_type);
689 if (data_ptr) {
690 switch (stktable_data_types[data_type].std_type) {
691 case STD_T_SINT: {
692 int data;
693
694 data = stktable_data_cast(data_ptr, std_t_sint);
695 intencode(data, &cursor);
696 break;
697 }
698 case STD_T_UINT: {
699 unsigned int data;
700
701 data = stktable_data_cast(data_ptr, std_t_uint);
702 intencode(data, &cursor);
703 break;
704 }
705 case STD_T_ULL: {
706 unsigned long long data;
707
708 data = stktable_data_cast(data_ptr, std_t_ull);
709 intencode(data, &cursor);
710 break;
711 }
712 case STD_T_FRQP: {
713 struct freq_ctr_period *frqp;
714
715 frqp = &stktable_data_cast(data_ptr, std_t_frqp);
716 intencode((unsigned int)(now_ms - frqp->curr_tick), &cursor);
717 intencode(frqp->curr_ctr, &cursor);
718 intencode(frqp->prev_ctr, &cursor);
719 break;
720 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200721 case STD_T_DICT: {
722 struct dict_entry *de;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200723 struct ebpt_node *cached_de;
Willy Tarreau237f8ae2019-06-06 16:40:43 +0200724 struct dcache_tx_entry cde = { };
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200725 char *beg, *end;
726 size_t value_len, data_len;
727 struct dcache *dc;
728
729 de = stktable_data_cast(data_ptr, std_t_dict);
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100730 if (!de) {
731 /* No entry */
732 intencode(0, &cursor);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200733 break;
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100734 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200735
736 dc = peer->dcache;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200737 cde.entry.key = de;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200738 cached_de = dcache_tx_insert(dc, &cde);
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200739 if (cached_de == &cde.entry) {
740 if (cde.id + 1 >= PEER_ENC_2BYTES_MIN)
741 break;
742 /* Encode the length of the remaining data -> 1 */
743 intencode(1, &cursor);
744 /* Encode the cache entry ID */
745 intencode(cde.id + 1, &cursor);
746 }
747 else {
748 /* Leave enough room to encode the remaining data length. */
749 end = beg = cursor + PEER_MSG_ENC_LENGTH_MAXLEN;
750 /* Encode the dictionary entry key */
751 intencode(cde.id + 1, &end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200752 /* Encode the length of the dictionary entry data */
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200753 value_len = de->len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200754 intencode(value_len, &end);
755 /* Copy the data */
756 memcpy(end, de->value.key, value_len);
757 end += value_len;
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200758 /* Encode the length of the data */
759 data_len = end - beg;
760 intencode(data_len, &cursor);
761 memmove(cursor, beg, data_len);
762 cursor += data_len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200763 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200764 break;
765 }
Emeric Brun94900952015-06-11 18:25:54 +0200766 }
767 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200768 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100769 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200770
771 /* Compute datalen */
772 datalen = (cursor - datamsg);
773
774 /* prepare message header */
775 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200776 peer_set_update_msg_type(&msg[1], use_identifier, use_timed);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200777 cursor = &msg[2];
778 intencode(datalen, &cursor);
779
780 /* move data after header */
781 memmove(cursor, datamsg, datalen);
782
783 /* return header size + data_len */
784 return (cursor - msg) + datalen;
785}
786
787/*
788 * This prepare the switch table message to targeted share table <st>.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800789 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200790 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
791 * check size)
792 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100793static int peer_prepare_switchmsg(char *msg, size_t size, struct peer_prep_params *params)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200794{
795 int len;
796 unsigned short datalen;
Willy Tarreau83061a82018-07-13 11:56:34 +0200797 struct buffer *chunk;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200798 char *cursor, *datamsg, *chunkp, *chunkq;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200799 uint64_t data = 0;
Emeric Brun94900952015-06-11 18:25:54 +0200800 unsigned int data_type;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100801 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200802
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100803 st = params->swtch.shared_table;
Frédéric Lécaille39143342019-05-24 14:32:27 +0200804 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200805
806 /* Encode data */
807
808 /* encode local id */
809 intencode(st->local_id, &cursor);
810
811 /* encode table name */
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100812 len = strlen(st->table->nid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200813 intencode(len, &cursor);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100814 memcpy(cursor, st->table->nid, len);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200815 cursor += len;
816
817 /* encode table type */
818
Emeric Brun530ba382020-06-02 11:17:42 +0200819 intencode(peer_net_key_type[st->table->type], &cursor);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200820
821 /* encode table key size */
822 intencode(st->table->key_size, &cursor);
823
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200824 chunk = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200825 chunkp = chunkq = chunk->area;
Emeric Brun94900952015-06-11 18:25:54 +0200826 /* encode available known data types in table */
827 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
828 if (st->table->data_ofs[data_type]) {
829 switch (stktable_data_types[data_type].std_type) {
830 case STD_T_SINT:
831 case STD_T_UINT:
832 case STD_T_ULL:
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200833 case STD_T_DICT:
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200834 data |= 1 << data_type;
835 break;
Emeric Brun94900952015-06-11 18:25:54 +0200836 case STD_T_FRQP:
837 data |= 1 << data_type;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200838 intencode(data_type, &chunkq);
839 intencode(st->table->data_arg[data_type].u, &chunkq);
Emeric Brun94900952015-06-11 18:25:54 +0200840 break;
841 }
842 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200843 }
844 intencode(data, &cursor);
845
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200846 /* Encode stick-table entries duration. */
847 intencode(st->table->expire, &cursor);
848
849 if (chunkq > chunkp) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200850 chunk->data = chunkq - chunkp;
851 memcpy(cursor, chunk->area, chunk->data);
852 cursor += chunk->data;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200853 }
854
Emeric Brunb3971ab2015-05-12 18:49:09 +0200855 /* Compute datalen */
856 datalen = (cursor - datamsg);
Emeric Brun2b920a12010-09-23 18:30:22 +0200857
Emeric Brunb3971ab2015-05-12 18:49:09 +0200858 /* prepare message header */
859 msg[0] = PEER_MSG_CLASS_STICKTABLE;
860 msg[1] = PEER_MSG_STKT_DEFINE;
861 cursor = &msg[2];
862 intencode(datalen, &cursor);
Emeric Brun2b920a12010-09-23 18:30:22 +0200863
Emeric Brunb3971ab2015-05-12 18:49:09 +0200864 /* move data after header */
865 memmove(cursor, datamsg, datalen);
866
867 /* return header size + data_len */
868 return (cursor - msg) + datalen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200869}
870
Emeric Brunb3971ab2015-05-12 18:49:09 +0200871/*
872 * This prepare the acknowledge message on the stick session <ts>, <st> is the considered
873 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800874 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200875 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
876 * check size)
877 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100878static int peer_prepare_ackmsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200879{
880 unsigned short datalen;
881 char *cursor, *datamsg;
882 uint32_t netinteger;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100883 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200884
Frédéric Lécaille39143342019-05-24 14:32:27 +0200885 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200886
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100887 st = p->ack.shared_table;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200888 intencode(st->remote_id, &cursor);
889 netinteger = htonl(st->last_get);
890 memcpy(cursor, &netinteger, sizeof(netinteger));
891 cursor += sizeof(netinteger);
892
893 /* Compute datalen */
894 datalen = (cursor - datamsg);
895
896 /* prepare message header */
897 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Emeric Brune1ab8082015-08-21 11:48:54 +0200898 msg[1] = PEER_MSG_STKT_ACK;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200899 cursor = &msg[2];
900 intencode(datalen, &cursor);
901
902 /* move data after header */
903 memmove(cursor, datamsg, datalen);
904
905 /* return header size + data_len */
906 return (cursor - msg) + datalen;
907}
Emeric Brun2b920a12010-09-23 18:30:22 +0200908
909/*
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200910 * Function to deinit connected peer
911 */
912void __peer_session_deinit(struct peer *peer)
913{
914 struct stream_interface *si;
915 struct stream *s;
916 struct peers *peers;
917
918 if (!peer->appctx)
919 return;
920
921 si = peer->appctx->owner;
922 if (!si)
923 return;
924
925 s = si_strm(si);
926 if (!s)
927 return;
928
929 peers = strm_fe(s)->parent;
930 if (!peers)
931 return;
932
933 if (peer->appctx->st0 == PEER_SESS_ST_WAITMSG)
934 HA_ATOMIC_SUB(&connected_peers, 1);
935
936 HA_ATOMIC_SUB(&active_peers, 1);
937
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200938 flush_dcache(peer);
939
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200940 /* Re-init current table pointers to force announcement on re-connect */
941 peer->remote_table = peer->last_local_table = NULL;
942 peer->appctx = NULL;
943 if (peer->flags & PEER_F_LEARN_ASSIGN) {
944 /* unassign current peer for learning */
945 peer->flags &= ~(PEER_F_LEARN_ASSIGN);
946 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
947
948 /* reschedule a resync */
949 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
950 }
951 /* reset teaching and learning flags to 0 */
952 peer->flags &= PEER_TEACH_RESET;
953 peer->flags &= PEER_LEARN_RESET;
954 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
955}
956
957/*
Emeric Brun2b920a12010-09-23 18:30:22 +0200958 * Callback to release a session with a peer
959 */
Willy Tarreau00a37f02015-04-13 12:05:19 +0200960static void peer_session_release(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +0200961{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200962 struct peer *peer = appctx->ctx.peers.ptr;
Emeric Brun2b920a12010-09-23 18:30:22 +0200963
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +0100964 TRACE_PROTO("releasing peer session", PEERS_EV_SESSREL, NULL, peer);
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100965 /* appctx->ctx.peers.ptr is not a peer session */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100966 if (appctx->st0 < PEER_SESS_ST_SENDSUCCESS)
Emeric Brun2b920a12010-09-23 18:30:22 +0200967 return;
968
969 /* peer session identified */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200970 if (peer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100971 HA_SPIN_LOCK(PEER_LOCK, &peer->lock);
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200972 if (peer->appctx == appctx)
973 __peer_session_deinit(peer);
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +0200974 peer->flags &= ~PEER_F_ALIVE;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100975 HA_SPIN_UNLOCK(PEER_LOCK, &peer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +0200976 }
977}
978
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200979/* Retrieve the major and minor versions of peers protocol
980 * announced by a remote peer. <str> is a null-terminated
981 * string with the following format: "<maj_ver>.<min_ver>".
982 */
983static int peer_get_version(const char *str,
984 unsigned int *maj_ver, unsigned int *min_ver)
985{
986 unsigned int majv, minv;
987 const char *pos, *saved;
988 const char *end;
989
990 saved = pos = str;
991 end = str + strlen(str);
992
993 majv = read_uint(&pos, end);
994 if (saved == pos || *pos++ != '.')
995 return -1;
996
997 saved = pos;
998 minv = read_uint(&pos, end);
999 if (saved == pos || pos != end)
1000 return -1;
1001
1002 *maj_ver = majv;
1003 *min_ver = minv;
1004
1005 return 0;
1006}
Emeric Brun2b920a12010-09-23 18:30:22 +02001007
1008/*
Frédéric Lécaillece025572019-01-21 13:38:06 +01001009 * Parse a line terminated by an optional '\r' character, followed by a mandatory
1010 * '\n' character.
1011 * Returns 1 if succeeded or 0 if a '\n' character could not be found, and -1 if
1012 * a line could not be read because the communication channel is closed.
1013 */
1014static inline int peer_getline(struct appctx *appctx)
1015{
1016 int n;
1017 struct stream_interface *si = appctx->owner;
1018
1019 n = co_getline(si_oc(si), trash.area, trash.size);
1020 if (!n)
1021 return 0;
1022
1023 if (n < 0 || trash.area[n - 1] != '\n') {
1024 appctx->st0 = PEER_SESS_ST_END;
1025 return -1;
1026 }
1027
1028 if (n > 1 && (trash.area[n - 2] == '\r'))
1029 trash.area[n - 2] = 0;
1030 else
1031 trash.area[n - 1] = 0;
1032
1033 co_skip(si_oc(si), n);
1034
1035 return n;
1036}
1037
1038/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001039 * Send a message after having called <peer_prepare_msg> to build it.
1040 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1041 * Returns -1 if there was not enough room left to send the message,
1042 * any other negative returned value must be considered as an error with an appcxt st0
1043 * returned value equal to PEER_SESS_ST_END.
1044 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001045static inline int peer_send_msg(struct appctx *appctx,
1046 int (*peer_prepare_msg)(char *, size_t, struct peer_prep_params *),
1047 struct peer_prep_params *params)
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001048{
1049 int ret, msglen;
1050 struct stream_interface *si = appctx->owner;
1051
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001052 msglen = peer_prepare_msg(trash.area, trash.size, params);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001053 if (!msglen) {
1054 /* internal error: message does not fit in trash */
1055 appctx->st0 = PEER_SESS_ST_END;
1056 return 0;
1057 }
1058
1059 /* message to buffer */
1060 ret = ci_putblk(si_ic(si), trash.area, msglen);
1061 if (ret <= 0) {
1062 if (ret == -1) {
1063 /* No more write possible */
1064 si_rx_room_blk(si);
1065 return -1;
1066 }
1067 appctx->st0 = PEER_SESS_ST_END;
1068 }
1069
1070 return ret;
1071}
1072
1073/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001074 * Send a hello message.
1075 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1076 * Returns -1 if there was not enough room left to send the message,
1077 * any other negative returned value must be considered as an error with an appcxt st0
1078 * returned value equal to PEER_SESS_ST_END.
1079 */
1080static inline int peer_send_hellomsg(struct appctx *appctx, struct peer *peer)
1081{
1082 struct peer_prep_params p = {
1083 .hello.peer = peer,
1084 };
1085
1086 return peer_send_msg(appctx, peer_prepare_hellomsg, &p);
1087}
1088
1089/*
1090 * Send a success peer handshake status message.
1091 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1092 * Returns -1 if there was not enough room left to send the message,
1093 * any other negative returned value must be considered as an error with an appcxt st0
1094 * returned value equal to PEER_SESS_ST_END.
1095 */
1096static inline int peer_send_status_successmsg(struct appctx *appctx)
1097{
1098 return peer_send_msg(appctx, peer_prepare_status_successmsg, NULL);
1099}
1100
1101/*
1102 * Send a peer handshake status error message.
1103 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1104 * Returns -1 if there was not enough room left to send the message,
1105 * any other negative returned value must be considered as an error with an appcxt st0
1106 * returned value equal to PEER_SESS_ST_END.
1107 */
1108static inline int peer_send_status_errormsg(struct appctx *appctx)
1109{
1110 struct peer_prep_params p = {
1111 .error_status.st1 = appctx->st1,
1112 };
1113
1114 return peer_send_msg(appctx, peer_prepare_status_errormsg, &p);
1115}
1116
1117/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001118 * Send a stick-table switch message.
1119 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1120 * Returns -1 if there was not enough room left to send the message,
1121 * any other negative returned value must be considered as an error with an appcxt st0
1122 * returned value equal to PEER_SESS_ST_END.
1123 */
1124static inline int peer_send_switchmsg(struct shared_table *st, struct appctx *appctx)
1125{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001126 struct peer_prep_params p = {
1127 .swtch.shared_table = st,
1128 };
1129
1130 return peer_send_msg(appctx, peer_prepare_switchmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001131}
1132
1133/*
1134 * Send a stick-table update acknowledgement message.
1135 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1136 * Returns -1 if there was not enough room left to send the message,
1137 * any other negative returned value must be considered as an error with an appcxt st0
1138 * returned value equal to PEER_SESS_ST_END.
1139 */
1140static inline int peer_send_ackmsg(struct shared_table *st, struct appctx *appctx)
1141{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001142 struct peer_prep_params p = {
1143 .ack.shared_table = st,
1144 };
1145
1146 return peer_send_msg(appctx, peer_prepare_ackmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001147}
1148
1149/*
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001150 * Send a stick-table update message.
1151 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1152 * Returns -1 if there was not enough room left to send the message,
1153 * any other negative returned value must be considered as an error with an appcxt st0
1154 * returned value equal to PEER_SESS_ST_END.
1155 */
1156static inline int peer_send_updatemsg(struct shared_table *st, struct appctx *appctx, struct stksess *ts,
1157 unsigned int updateid, int use_identifier, int use_timed)
1158{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001159 struct peer_prep_params p = {
Willy Tarreaua898f0c2020-07-03 19:09:29 +02001160 .updt = {
1161 .stksess = ts,
1162 .shared_table = st,
1163 .updateid = updateid,
1164 .use_identifier = use_identifier,
1165 .use_timed = use_timed,
1166 .peer = appctx->ctx.peers.ptr,
1167 },
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001168 };
1169
1170 return peer_send_msg(appctx, peer_prepare_updatemsg, &p);
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001171}
1172
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001173/*
1174 * Build a peer protocol control class message.
1175 * Returns the number of written bytes used to build the message if succeeded,
1176 * 0 if not.
1177 */
1178static int peer_prepare_control_msg(char *msg, size_t size, struct peer_prep_params *p)
1179{
1180 if (size < sizeof p->control.head)
1181 return 0;
1182
1183 msg[0] = p->control.head[0];
1184 msg[1] = p->control.head[1];
1185
1186 return 2;
1187}
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001188
1189/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001190 * Send a stick-table synchronization request message.
1191 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1192 * Returns -1 if there was not enough room left to send the message,
1193 * any other negative returned value must be considered as an error with an appctx st0
1194 * returned value equal to PEER_SESS_ST_END.
1195 */
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001196static inline int peer_send_resync_reqmsg(struct appctx *appctx,
1197 struct peer *peer, struct peers *peers)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001198{
1199 struct peer_prep_params p = {
1200 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCREQ, },
1201 };
1202
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001203 TRACE_PROTO("send control message", PEERS_EV_CTRLMSG,
1204 NULL, &p.control.head[1], peers->local->id, peer->id);
1205
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001206 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1207}
1208
1209/*
1210 * Send a stick-table synchronization confirmation message.
1211 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1212 * Returns -1 if there was not enough room left to send the message,
1213 * any other negative returned value must be considered as an error with an appctx st0
1214 * returned value equal to PEER_SESS_ST_END.
1215 */
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001216static inline int peer_send_resync_confirmsg(struct appctx *appctx,
1217 struct peer *peer, struct peers *peers)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001218{
1219 struct peer_prep_params p = {
1220 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCCONFIRM, },
1221 };
1222
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001223 TRACE_PROTO("send control message", PEERS_EV_CTRLMSG,
1224 NULL, &p.control.head[1], peers->local->id, peer->id);
1225
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001226 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1227}
1228
1229/*
1230 * Send a stick-table synchronization finished message.
1231 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1232 * Returns -1 if there was not enough room left to send the message,
1233 * any other negative returned value must be considered as an error with an appctx st0
1234 * returned value equal to PEER_SESS_ST_END.
1235 */
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001236static inline int peer_send_resync_finishedmsg(struct appctx *appctx,
1237 struct peer *peer, struct peers *peers)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001238{
1239 struct peer_prep_params p = {
1240 .control.head = { PEER_MSG_CLASS_CONTROL, },
1241 };
1242
Emeric Brun70de43b2020-03-16 10:51:01 +01001243 p.control.head[1] = (peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED ?
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001244 PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
1245
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001246 TRACE_PROTO("send control message", PEERS_EV_CTRLMSG,
1247 NULL, &p.control.head[1], peers->local->id, peer->id);
1248
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001249 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1250}
1251
1252/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001253 * Send a heartbeat message.
1254 * Return 0 if the message could not be built modifying the appctx st0 to PEER_SESS_ST_END value.
1255 * Returns -1 if there was not enough room left to send the message,
1256 * any other negative returned value must be considered as an error with an appctx st0
1257 * returned value equal to PEER_SESS_ST_END.
1258 */
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001259static inline int peer_send_heartbeatmsg(struct appctx *appctx,
1260 struct peer *peer, struct peers *peers)
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001261{
1262 struct peer_prep_params p = {
1263 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_HEARTBEAT, },
1264 };
1265
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001266 TRACE_PROTO("send control message", PEERS_EV_CTRLMSG,
1267 NULL, &p.control.head[1], peers->local->id, peer->id);
1268
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001269 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1270}
1271
1272/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001273 * Build a peer protocol error class message.
1274 * Returns the number of written bytes used to build the message if succeeded,
1275 * 0 if not.
1276 */
1277static int peer_prepare_error_msg(char *msg, size_t size, struct peer_prep_params *p)
1278{
1279 if (size < sizeof p->error.head)
1280 return 0;
1281
1282 msg[0] = p->error.head[0];
1283 msg[1] = p->error.head[1];
1284
1285 return 2;
1286}
1287
1288/*
1289 * Send a "size limit reached" error message.
1290 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1291 * Returns -1 if there was not enough room left to send the message,
1292 * any other negative returned value must be considered as an error with an appctx st0
1293 * returned value equal to PEER_SESS_ST_END.
1294 */
1295static inline int peer_send_error_size_limitmsg(struct appctx *appctx)
1296{
1297 struct peer_prep_params p = {
1298 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_SIZELIMIT, },
1299 };
1300
1301 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1302}
1303
1304/*
1305 * Send a "peer protocol" error message.
1306 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1307 * Returns -1 if there was not enough room left to send the message,
1308 * any other negative returned value must be considered as an error with an appctx st0
1309 * returned value equal to PEER_SESS_ST_END.
1310 */
1311static inline int peer_send_error_protomsg(struct appctx *appctx)
1312{
1313 struct peer_prep_params p = {
1314 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_PROTOCOL, },
1315 };
1316
1317 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1318}
1319
1320/*
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001321 * Function used to lookup for recent stick-table updates associated with
1322 * <st> shared stick-table when a lesson must be taught a peer (PEER_F_LEARN_ASSIGN flag set).
1323 */
1324static inline struct stksess *peer_teach_process_stksess_lookup(struct shared_table *st)
1325{
1326 struct eb32_node *eb;
1327
1328 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1329 if (!eb) {
1330 eb = eb32_first(&st->table->updates);
1331 if (!eb || ((int)(eb->key - st->last_pushed) <= 0)) {
1332 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1333 return NULL;
1334 }
1335 }
1336
1337 if ((int)(eb->key - st->table->localupdate) > 0) {
1338 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1339 return NULL;
1340 }
1341
1342 return eb32_entry(eb, struct stksess, upd);
1343}
1344
1345/*
1346 * Function used to lookup for recent stick-table updates associated with
1347 * <st> shared stick-table during teach state 1 step.
1348 */
1349static inline struct stksess *peer_teach_stage1_stksess_lookup(struct shared_table *st)
1350{
1351 struct eb32_node *eb;
1352
1353 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1354 if (!eb) {
1355 st->flags |= SHTABLE_F_TEACH_STAGE1;
1356 eb = eb32_first(&st->table->updates);
1357 if (eb)
1358 st->last_pushed = eb->key - 1;
1359 return NULL;
1360 }
1361
1362 return eb32_entry(eb, struct stksess, upd);
1363}
1364
1365/*
1366 * Function used to lookup for recent stick-table updates associated with
1367 * <st> shared stick-table during teach state 2 step.
1368 */
1369static inline struct stksess *peer_teach_stage2_stksess_lookup(struct shared_table *st)
1370{
1371 struct eb32_node *eb;
1372
1373 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1374 if (!eb || eb->key > st->teaching_origin) {
1375 st->flags |= SHTABLE_F_TEACH_STAGE2;
1376 return NULL;
1377 }
1378
1379 return eb32_entry(eb, struct stksess, upd);
1380}
1381
1382/*
1383 * Generic function to emit update messages for <st> stick-table when a lesson must
1384 * be taught to the peer <p>.
1385 * <locked> must be set to 1 if the shared table <st> is already locked when entering
1386 * this function, 0 if not.
1387 *
1388 * This function temporary unlock/lock <st> when it sends stick-table updates or
1389 * when decrementing its refcount in case of any error when it sends this updates.
1390 *
1391 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1392 * Returns -1 if there was not enough room left to send the message,
1393 * any other negative returned value must be considered as an error with an appcxt st0
1394 * returned value equal to PEER_SESS_ST_END.
1395 * If it returns 0 or -1, this function leave <st> locked if already locked when entering this function
1396 * unlocked if not already locked when entering this function.
1397 */
1398static inline int peer_send_teachmsgs(struct appctx *appctx, struct peer *p,
1399 struct stksess *(*peer_stksess_lookup)(struct shared_table *),
1400 struct shared_table *st, int locked)
1401{
1402 int ret, new_pushed, use_timed;
1403
1404 ret = 1;
1405 use_timed = 0;
1406 if (st != p->last_local_table) {
1407 ret = peer_send_switchmsg(st, appctx);
1408 if (ret <= 0)
1409 return ret;
1410
1411 p->last_local_table = st;
1412 }
1413
1414 if (peer_stksess_lookup != peer_teach_process_stksess_lookup)
1415 use_timed = !(p->flags & PEER_F_DWNGRD);
1416
1417 /* We force new pushed to 1 to force identifier in update message */
1418 new_pushed = 1;
1419
1420 if (!locked)
1421 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1422
1423 while (1) {
1424 struct stksess *ts;
1425 unsigned updateid;
1426
1427 /* push local updates */
1428 ts = peer_stksess_lookup(st);
1429 if (!ts)
1430 break;
1431
1432 updateid = ts->upd.key;
1433 ts->ref_cnt++;
1434 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1435
1436 ret = peer_send_updatemsg(st, appctx, ts, updateid, new_pushed, use_timed);
1437 if (ret <= 0) {
1438 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1439 ts->ref_cnt--;
1440 if (!locked)
1441 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1442 return ret;
1443 }
1444
1445 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1446 ts->ref_cnt--;
1447 st->last_pushed = updateid;
1448
1449 if (peer_stksess_lookup == peer_teach_process_stksess_lookup &&
1450 (int)(st->last_pushed - st->table->commitupdate) > 0)
1451 st->table->commitupdate = st->last_pushed;
1452
1453 /* identifier may not needed in next update message */
1454 new_pushed = 0;
1455 }
1456
1457 out:
1458 if (!locked)
1459 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1460 return 1;
1461}
1462
1463/*
1464 * Function to emit update messages for <st> stick-table when a lesson must
1465 * be taught to the peer <p> (PEER_F_LEARN_ASSIGN flag set).
1466 *
1467 * Note that <st> shared stick-table is locked when calling this function.
1468 *
1469 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1470 * Returns -1 if there was not enough room left to send the message,
1471 * any other negative returned value must be considered as an error with an appcxt st0
1472 * returned value equal to PEER_SESS_ST_END.
1473 */
1474static inline int peer_send_teach_process_msgs(struct appctx *appctx, struct peer *p,
1475 struct shared_table *st)
1476{
1477 return peer_send_teachmsgs(appctx, p, peer_teach_process_stksess_lookup, st, 1);
1478}
1479
1480/*
1481 * Function to emit update messages for <st> stick-table when a lesson must
1482 * be taught to the peer <p> during teach state 1 step.
1483 *
1484 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1485 * Returns -1 if there was not enough room left to send the message,
1486 * any other negative returned value must be considered as an error with an appcxt st0
1487 * returned value equal to PEER_SESS_ST_END.
1488 */
1489static inline int peer_send_teach_stage1_msgs(struct appctx *appctx, struct peer *p,
1490 struct shared_table *st)
1491{
1492 return peer_send_teachmsgs(appctx, p, peer_teach_stage1_stksess_lookup, st, 0);
1493}
1494
1495/*
1496 * Function to emit update messages for <st> stick-table when a lesson must
1497 * be taught to the peer <p> during teach state 1 step.
1498 *
1499 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1500 * Returns -1 if there was not enough room left to send the message,
1501 * any other negative returned value must be considered as an error with an appcxt st0
1502 * returned value equal to PEER_SESS_ST_END.
1503 */
1504static inline int peer_send_teach_stage2_msgs(struct appctx *appctx, struct peer *p,
1505 struct shared_table *st)
1506{
1507 return peer_send_teachmsgs(appctx, p, peer_teach_stage2_stksess_lookup, st, 0);
1508}
1509
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001510
1511/*
1512 * Function used to parse a stick-table update message after it has been received
1513 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1514 * receipt buffer with <msg_end> being position of the end of the stick-table message.
1515 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1516 * was encountered.
1517 * <exp> must be set if the stick-table entry expires.
1518 * <updt> must be set for PEER_MSG_STKT_UPDATE or PEER_MSG_STKT_UPDATE_TIMED stick-table
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001519 * messages, in this case the stick-table update message is received with a stick-table
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001520 * update ID.
1521 * <totl> is the length of the stick-table update message computed upon receipt.
1522 */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001523static int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int exp,
1524 char **msg_cur, char *msg_end, int msg_len, int totl)
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001525{
1526 struct stream_interface *si = appctx->owner;
1527 struct shared_table *st = p->remote_table;
1528 struct stksess *ts, *newts;
1529 uint32_t update;
1530 int expire;
1531 unsigned int data_type;
1532 void *data_ptr;
1533
Frédéric Lécaille94571512020-11-10 16:18:03 +01001534 TRACE_ENTER(PEERS_EV_UPDTMSG, NULL, p);
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001535 /* Here we have data message */
1536 if (!st)
1537 goto ignore_msg;
1538
1539 expire = MS_TO_TICKS(st->table->expire);
1540
1541 if (updt) {
Frédéric Lécaille94571512020-11-10 16:18:03 +01001542 if (msg_len < sizeof(update)) {
1543 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001544 goto malformed_exit;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001545 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001546
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001547 memcpy(&update, *msg_cur, sizeof(update));
1548 *msg_cur += sizeof(update);
1549 st->last_get = htonl(update);
1550 }
1551 else {
1552 st->last_get++;
1553 }
1554
1555 if (exp) {
1556 size_t expire_sz = sizeof expire;
1557
Frédéric Lécaille94571512020-11-10 16:18:03 +01001558 if (*msg_cur + expire_sz > msg_end) {
1559 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1560 NULL, p, *msg_cur);
1561 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1562 NULL, p, msg_end, &expire_sz);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001563 goto malformed_exit;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001564 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001565
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001566 memcpy(&expire, *msg_cur, expire_sz);
1567 *msg_cur += expire_sz;
1568 expire = ntohl(expire);
1569 }
1570
1571 newts = stksess_new(st->table, NULL);
1572 if (!newts)
1573 goto ignore_msg;
1574
1575 if (st->table->type == SMP_T_STR) {
1576 unsigned int to_read, to_store;
1577
1578 to_read = intdecode(msg_cur, msg_end);
Frédéric Lécaille94571512020-11-10 16:18:03 +01001579 if (!*msg_cur) {
1580 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001581 goto malformed_free_newts;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001582 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001583
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001584 to_store = MIN(to_read, st->table->key_size - 1);
Frédéric Lécaille94571512020-11-10 16:18:03 +01001585 if (*msg_cur + to_store > msg_end) {
1586 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1587 NULL, p, *msg_cur);
1588 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1589 NULL, p, msg_end, &to_store);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001590 goto malformed_free_newts;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001591 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001592
1593 memcpy(newts->key.key, *msg_cur, to_store);
1594 newts->key.key[to_store] = 0;
1595 *msg_cur += to_read;
1596 }
1597 else if (st->table->type == SMP_T_SINT) {
1598 unsigned int netinteger;
1599
Frédéric Lécaille94571512020-11-10 16:18:03 +01001600 if (*msg_cur + sizeof(netinteger) > msg_end) {
1601 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1602 NULL, p, *msg_cur);
1603 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1604 NULL, p, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001605 goto malformed_free_newts;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001606 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001607
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001608 memcpy(&netinteger, *msg_cur, sizeof(netinteger));
1609 netinteger = ntohl(netinteger);
1610 memcpy(newts->key.key, &netinteger, sizeof(netinteger));
1611 *msg_cur += sizeof(netinteger);
1612 }
1613 else {
Frédéric Lécaille94571512020-11-10 16:18:03 +01001614 if (*msg_cur + st->table->key_size > msg_end) {
1615 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1616 NULL, p, *msg_cur);
1617 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1618 NULL, p, msg_end, &st->table->key_size);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001619 goto malformed_free_newts;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001620 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001621
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001622 memcpy(newts->key.key, *msg_cur, st->table->key_size);
1623 *msg_cur += st->table->key_size;
1624 }
1625
1626 /* lookup for existing entry */
1627 ts = stktable_set_entry(st->table, newts);
1628 if (ts != newts) {
1629 stksess_free(st->table, newts);
1630 newts = NULL;
1631 }
1632
1633 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
1634
1635 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001636 uint64_t decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001637
1638 if (!((1 << data_type) & st->remote_data))
1639 continue;
1640
Willy Tarreau1e82a142019-01-29 11:08:06 +01001641 decoded_int = intdecode(msg_cur, msg_end);
Frédéric Lécaille94571512020-11-10 16:18:03 +01001642 if (!*msg_cur) {
1643 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001644 goto malformed_unlock;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001645 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001646
Willy Tarreau1e82a142019-01-29 11:08:06 +01001647 switch (stktable_data_types[data_type].std_type) {
1648 case STD_T_SINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001649 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1650 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001651 stktable_data_cast(data_ptr, std_t_sint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001652 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001653
Willy Tarreau1e82a142019-01-29 11:08:06 +01001654 case STD_T_UINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001655 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1656 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001657 stktable_data_cast(data_ptr, std_t_uint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001658 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001659
Willy Tarreau1e82a142019-01-29 11:08:06 +01001660 case STD_T_ULL:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001661 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1662 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001663 stktable_data_cast(data_ptr, std_t_ull) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001664 break;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001665
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001666 case STD_T_FRQP: {
1667 struct freq_ctr_period data;
1668
1669 /* First bit is reserved for the freq_ctr_period lock
1670 Note: here we're still protected by the stksess lock
1671 so we don't need to update the update the freq_ctr_period
1672 using its internal lock */
1673
Willy Tarreau1e82a142019-01-29 11:08:06 +01001674 data.curr_tick = tick_add(now_ms, -decoded_int) & ~0x1;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001675 data.curr_ctr = intdecode(msg_cur, msg_end);
Frédéric Lécaille94571512020-11-10 16:18:03 +01001676 if (!*msg_cur) {
1677 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001678 goto malformed_unlock;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001679 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001680
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001681 data.prev_ctr = intdecode(msg_cur, msg_end);
Frédéric Lécaille94571512020-11-10 16:18:03 +01001682 if (!*msg_cur) {
1683 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001684 goto malformed_unlock;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001685 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001686
1687 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1688 if (data_ptr)
1689 stktable_data_cast(data_ptr, std_t_frqp) = data;
1690 break;
1691 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001692 case STD_T_DICT: {
1693 struct buffer *chunk;
1694 size_t data_len, value_len;
1695 unsigned int id;
1696 struct dict_entry *de;
1697 struct dcache *dc;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001698 char *end;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001699
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +01001700 if (!decoded_int) {
1701 /* No entry. */
1702 break;
1703 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001704 data_len = decoded_int;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001705 if (*msg_cur + data_len > msg_end) {
1706 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1707 NULL, p, *msg_cur);
1708 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1709 NULL, p, msg_end, &data_len);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001710 goto malformed_unlock;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001711 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001712
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001713 /* Compute the end of the current data, <msg_end> being at the end of
1714 * the entire message.
1715 */
1716 end = *msg_cur + data_len;
1717 id = intdecode(msg_cur, end);
Frédéric Lécaille94571512020-11-10 16:18:03 +01001718 if (!*msg_cur || !id) {
1719 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1720 NULL, p, *msg_cur, &id);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001721 goto malformed_unlock;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001722 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001723
1724 dc = p->dcache;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001725 if (*msg_cur == end) {
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001726 /* Dictionary entry key without value. */
Frédéric Lécaillecd24d5c2020-11-12 19:53:11 +01001727 if (id > dc->max_entries) {
Frédéric Lécaille94571512020-11-10 16:18:03 +01001728 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1729 NULL, p, NULL, &id);
Frédéric Lécaillecd24d5c2020-11-12 19:53:11 +01001730 goto malformed_unlock;
1731 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001732 /* IDs sent over the network are numbered from 1. */
1733 de = dc->rx[id - 1].de;
1734 }
1735 else {
1736 chunk = get_trash_chunk();
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001737 value_len = intdecode(msg_cur, end);
1738 if (!*msg_cur || *msg_cur + value_len > end ||
Frédéric Lécaille94571512020-11-10 16:18:03 +01001739 unlikely(value_len + 1 >= chunk->size)) {
1740 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1741 NULL, p, *msg_cur, &value_len);
1742 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1743 NULL, p, end, &chunk->size);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001744 goto malformed_unlock;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001745 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001746
1747 chunk_memcpy(chunk, *msg_cur, value_len);
1748 chunk->area[chunk->data] = '\0';
Frédéric Lécaille56aec0d2019-06-06 14:14:15 +02001749 *msg_cur += value_len;
1750
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001751 de = dict_insert(&server_name_dict, chunk->area);
1752 dc->rx[id - 1].de = de;
1753 }
1754 if (de) {
1755 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1756 if (data_ptr)
1757 stktable_data_cast(data_ptr, std_t_dict) = de;
1758 }
1759 break;
1760 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001761 }
1762 }
1763 /* Force new expiration */
1764 ts->expire = tick_add(now_ms, expire);
1765
1766 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1767 stktable_touch_remote(st->table, ts, 1);
Frédéric Lécaille94571512020-11-10 16:18:03 +01001768 TRACE_LEAVE(PEERS_EV_UPDTMSG, NULL, p);
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001769 return 1;
1770
1771 ignore_msg:
1772 /* skip consumed message */
1773 co_skip(si_oc(si), totl);
Frédéric Lécaille94571512020-11-10 16:18:03 +01001774 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001775 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001776
1777 malformed_unlock:
1778 /* malformed message */
1779 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1780 stktable_touch_remote(st->table, ts, 1);
1781 appctx->st0 = PEER_SESS_ST_ERRPROTO;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001782 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001783 return 0;
1784
1785 malformed_free_newts:
1786 /* malformed message */
1787 stksess_free(st->table, newts);
1788 malformed_exit:
1789 appctx->st0 = PEER_SESS_ST_ERRPROTO;
Frédéric Lécaille94571512020-11-10 16:18:03 +01001790 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001791 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001792}
1793
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001794/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001795 * Function used to parse a stick-table update acknowledgement message after it
1796 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1797 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1798 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1799 * was encountered.
1800 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1801 */
1802static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1803 char **msg_cur, char *msg_end)
1804{
1805 /* ack message */
1806 uint32_t table_id ;
1807 uint32_t update;
1808 struct shared_table *st;
1809
1810 table_id = intdecode(msg_cur, msg_end);
1811 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1812 /* malformed message */
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001813
1814 TRACE_PROTO("malformed message", PEERS_EV_ACKMSG,
1815 NULL, p, *msg_cur);
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001816 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1817 return 0;
1818 }
1819
1820 memcpy(&update, *msg_cur, sizeof(update));
1821 update = ntohl(update);
1822
1823 for (st = p->tables; st; st = st->next) {
1824 if (st->local_id == table_id) {
1825 st->update = update;
1826 break;
1827 }
1828 }
1829
1830 return 1;
1831}
1832
1833/*
1834 * Function used to parse a stick-table switch message after it has been received
1835 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1836 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1837 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1838 * was encountered.
1839 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1840 */
1841static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1842 char **msg_cur, char *msg_end)
1843{
1844 struct shared_table *st;
1845 int table_id;
1846
1847 table_id = intdecode(msg_cur, msg_end);
1848 if (!*msg_cur) {
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001849 TRACE_PROTO("malformed message", PEERS_EV_SWTCMSG, NULL, p);
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001850 /* malformed message */
1851 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1852 return 0;
1853 }
1854
1855 p->remote_table = NULL;
1856 for (st = p->tables; st; st = st->next) {
1857 if (st->remote_id == table_id) {
1858 p->remote_table = st;
1859 break;
1860 }
1861 }
1862
1863 return 1;
1864}
1865
1866/*
1867 * Function used to parse a stick-table definition message after it has been received
1868 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1869 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1870 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1871 * was encountered.
1872 * <totl> is the length of the stick-table update message computed upon receipt.
1873 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1874 */
1875static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1876 char **msg_cur, char *msg_end, int totl)
1877{
1878 struct stream_interface *si = appctx->owner;
1879 int table_id_len;
1880 struct shared_table *st;
1881 int table_type;
1882 int table_keylen;
1883 int table_id;
1884 uint64_t table_data;
1885
1886 table_id = intdecode(msg_cur, msg_end);
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001887 if (!*msg_cur) {
1888 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001889 goto malformed_exit;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001890 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001891
1892 table_id_len = intdecode(msg_cur, msg_end);
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001893 if (!*msg_cur) {
1894 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p, *msg_cur);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001895 goto malformed_exit;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001896 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001897
1898 p->remote_table = NULL;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001899 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end) {
1900 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p, *msg_cur, &table_id_len);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001901 goto malformed_exit;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001902 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001903
1904 for (st = p->tables; st; st = st->next) {
1905 /* Reset IDs */
1906 if (st->remote_id == table_id)
1907 st->remote_id = 0;
1908
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001909 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1910 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001911 p->remote_table = st;
1912 }
1913
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001914 if (!p->remote_table) {
1915 TRACE_PROTO("ignored message", PEERS_EV_DEFMSG, NULL, p);
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001916 goto ignore_msg;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001917 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001918
1919 *msg_cur += table_id_len;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001920 if (*msg_cur >= msg_end) {
1921 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001922 goto malformed_exit;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001923 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001924
1925 table_type = intdecode(msg_cur, msg_end);
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001926 if (!*msg_cur) {
1927 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001928 goto malformed_exit;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001929 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001930
1931 table_keylen = intdecode(msg_cur, msg_end);
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001932 if (!*msg_cur) {
1933 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001934 goto malformed_exit;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001935 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001936
1937 table_data = intdecode(msg_cur, msg_end);
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001938 if (!*msg_cur) {
1939 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001940 goto malformed_exit;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001941 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001942
Emeric Brun530ba382020-06-02 11:17:42 +02001943 if (p->remote_table->table->type != peer_int_key_type[table_type]
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001944 || p->remote_table->table->key_size != table_keylen) {
1945 p->remote_table = NULL;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01001946 TRACE_PROTO("ignored message", PEERS_EV_DEFMSG, NULL, p);
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001947 goto ignore_msg;
1948 }
1949
1950 p->remote_table->remote_data = table_data;
1951 p->remote_table->remote_id = table_id;
1952 return 1;
1953
1954 ignore_msg:
1955 co_skip(si_oc(si), totl);
1956 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001957
1958 malformed_exit:
1959 /* malformed message */
1960 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1961 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001962}
1963
1964/*
Willy Tarreaud4913912020-11-13 14:10:20 +01001965 * Receive a stick-table message or pre-parse any other message.
1966 * The message's header will be sent into <msg_head> which must be at least
1967 * <msg_head_sz> bytes long (at least 7 to store 32-bit variable lengths).
1968 * The first two bytes are always read, and the rest is only read if the
1969 * first bytes indicate a stick-table message. If the message is a stick-table
1970 * message, the varint is decoded and the equivalent number of bytes will be
1971 * copied into the trash at trash.area. <totl> is incremented by the number of
1972 * bytes read EVEN IN CASE OF INCOMPLETE MESSAGES.
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001973 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1974 * -1 if there was an error updating the appctx state st0 accordingly.
1975 */
1976static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1977 uint32_t *msg_len, int *totl)
1978{
1979 int reql;
1980 struct stream_interface *si = appctx->owner;
Willy Tarreaud4913912020-11-13 14:10:20 +01001981 char *cur;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001982
1983 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1984 if (reql <= 0) /* closed or EOL not found */
1985 goto incomplete;
1986
1987 *totl += reql;
1988
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001989 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001990 return 1;
1991
Willy Tarreaud4913912020-11-13 14:10:20 +01001992 /* This is a stick-table message, let's go on */
1993
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001994 /* Read and Decode message length */
Willy Tarreaud4913912020-11-13 14:10:20 +01001995 msg_head += *totl;
1996 msg_head_sz -= *totl;
1997 reql = co_data(si_oc(si)) - *totl;
1998 if (reql > msg_head_sz)
1999 reql = msg_head_sz;
2000
2001 reql = co_getblk(si_oc(si), msg_head, reql, *totl);
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002002 if (reql <= 0) /* closed */
2003 goto incomplete;
2004
Willy Tarreaud4913912020-11-13 14:10:20 +01002005 cur = msg_head;
2006 *msg_len = intdecode(&cur, cur + reql);
2007 if (!cur) {
2008 /* the number is truncated, did we read enough ? */
2009 if (reql < msg_head_sz)
2010 goto incomplete;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002011
Willy Tarreaud4913912020-11-13 14:10:20 +01002012 /* malformed message */
Frédéric Lécaille94571512020-11-10 16:18:03 +01002013 TRACE_PROTO("malformed message: too large length encoding", PEERS_EV_UPDTMSG);
Willy Tarreaud4913912020-11-13 14:10:20 +01002014 appctx->st0 = PEER_SESS_ST_ERRPROTO;
2015 return -1;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002016 }
Willy Tarreaud4913912020-11-13 14:10:20 +01002017 *totl += cur - msg_head;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002018
2019 /* Read message content */
2020 if (*msg_len) {
2021 if (*msg_len > trash.size) {
2022 /* Status code is not success, abort */
2023 appctx->st0 = PEER_SESS_ST_ERRSIZE;
2024 return -1;
2025 }
2026
2027 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
2028 if (reql <= 0) /* closed */
2029 goto incomplete;
2030 *totl += reql;
2031 }
2032
2033 return 1;
2034
2035 incomplete:
Willy Tarreau46af74a2020-11-26 17:06:04 +01002036 if (reql < 0 || (si_oc(si)->flags & (CF_SHUTW|CF_SHUTW_NOW))) {
2037 /* there was an error or the message was truncated */
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002038 appctx->st0 = PEER_SESS_ST_END;
2039 return -1;
2040 }
2041
2042 return 0;
2043}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002044
2045/*
2046 * Treat the awaited message with <msg_head> as header.*
2047 * Return 1 if succeeded, 0 if not.
2048 */
2049static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
2050 char **msg_cur, char *msg_end, int msg_len, int totl)
2051{
2052 struct stream_interface *si = appctx->owner;
2053 struct stream *s = si_strm(si);
2054 struct peers *peers = strm_fe(s)->parent;
2055
2056 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
2057 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
2058 struct shared_table *st;
2059 /* Reset message: remote need resync */
2060
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002061 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2062 NULL, &msg_head[1], peers->local->id, peer->id);
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002063 /* prepare tables for a global push */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002064 for (st = peer->tables; st; st = st->next) {
2065 st->teaching_origin = st->last_pushed = st->table->update;
2066 st->flags = 0;
2067 }
2068
2069 /* reset teaching flags to 0 */
2070 peer->flags &= PEER_TEACH_RESET;
2071
2072 /* flag to start to teach lesson */
2073 peer->flags |= PEER_F_TEACH_PROCESS;
2074 }
2075 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002076 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2077 NULL, &msg_head[1], peers->local->id, peer->id);
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002078 if (peer->flags & PEER_F_LEARN_ASSIGN) {
2079 peer->flags &= ~PEER_F_LEARN_ASSIGN;
2080 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2081 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
2082 }
2083 peer->confirm++;
2084 }
2085 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002086 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2087 NULL, &msg_head[1], peers->local->id, peer->id);
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002088 if (peer->flags & PEER_F_LEARN_ASSIGN) {
2089 peer->flags &= ~PEER_F_LEARN_ASSIGN;
2090 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2091
2092 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002093 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002094 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2095 }
2096 peer->confirm++;
2097 }
2098 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
2099 struct shared_table *st;
2100
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002101 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2102 NULL, &msg_head[1], peers->local->id, peer->id);
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002103 /* If stopping state */
2104 if (stopping) {
2105 /* Close session, push resync no more needed */
2106 peer->flags |= PEER_F_TEACH_COMPLETE;
2107 appctx->st0 = PEER_SESS_ST_END;
2108 return 0;
2109 }
2110 for (st = peer->tables; st; st = st->next) {
2111 st->update = st->last_pushed = st->teaching_origin;
2112 st->flags = 0;
2113 }
2114
2115 /* reset teaching flags to 0 */
2116 peer->flags &= PEER_TEACH_RESET;
2117 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002118 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002119 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2120 NULL, &msg_head[1], peers->local->id, peer->id);
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002121 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002122 peer->rx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002123 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002124 }
2125 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
2126 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
2127 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
2128 return 0;
2129 }
2130 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
2131 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
2132 return 0;
2133 }
2134 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
2135 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
2136 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
2137 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
2138 int update, expire;
2139
2140 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
2141 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
2142 if (!peer_treat_updatemsg(appctx, peer, update, expire,
2143 msg_cur, msg_end, msg_len, totl))
2144 return 0;
2145
2146 }
2147 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
2148 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
2149 return 0;
2150 }
2151 }
2152 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
2153 appctx->st0 = PEER_SESS_ST_ERRPROTO;
2154 return 0;
2155 }
2156
2157 return 1;
2158}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002159
2160
2161/*
2162 * Send any message to <peer> peer.
2163 * Returns 1 if succeeded, or -1 or 0 if failed.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002164 * -1 means an internal error occurred, 0 is for a peer protocol error leading
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002165 * to a peer state change (from the peer I/O handler point of view).
2166 */
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002167static inline int peer_send_msgs(struct appctx *appctx,
2168 struct peer *peer, struct peers *peers)
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002169{
2170 int repl;
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002171
2172 /* Need to request a resync */
2173 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
2174 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2175 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
2176
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002177 repl = peer_send_resync_reqmsg(appctx, peer, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002178 if (repl <= 0)
2179 return repl;
2180
2181 peers->flags |= PEERS_F_RESYNC_PROCESS;
2182 }
2183
2184 /* Nothing to read, now we start to write */
2185 if (peer->tables) {
2186 struct shared_table *st;
2187 struct shared_table *last_local_table;
2188
2189 last_local_table = peer->last_local_table;
2190 if (!last_local_table)
2191 last_local_table = peer->tables;
2192 st = last_local_table->next;
2193
2194 while (1) {
2195 if (!st)
2196 st = peer->tables;
2197
2198 /* It remains some updates to ack */
2199 if (st->last_get != st->last_acked) {
2200 repl = peer_send_ackmsg(st, appctx);
2201 if (repl <= 0)
2202 return repl;
2203
2204 st->last_acked = st->last_get;
2205 }
2206
2207 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
2208 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
2209 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
2210 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
2211
2212 repl = peer_send_teach_process_msgs(appctx, peer, st);
2213 if (repl <= 0) {
2214 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
2215 return repl;
2216 }
2217 }
2218 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
2219 }
2220 else {
2221 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
2222 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
2223 if (repl <= 0)
2224 return repl;
2225 }
2226
2227 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
2228 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
2229 if (repl <= 0)
2230 return repl;
2231 }
2232 }
2233
2234 if (st == last_local_table)
2235 break;
2236 st = st->next;
2237 }
2238 }
2239
2240 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002241 repl = peer_send_resync_finishedmsg(appctx, peer, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002242 if (repl <= 0)
2243 return repl;
2244
2245 /* flag finished message sent */
2246 peer->flags |= PEER_F_TEACH_FINISHED;
2247 }
2248
2249 /* Confirm finished or partial messages */
2250 while (peer->confirm) {
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002251 repl = peer_send_resync_confirmsg(appctx, peer, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002252 if (repl <= 0)
2253 return repl;
2254
2255 peer->confirm--;
2256 }
2257
2258 return 1;
2259}
2260
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002261/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002262 * Read and parse a first line of a "hello" peer protocol message.
2263 * Returns 0 if could not read a line, -1 if there was a read error or
2264 * the line is malformed, 1 if succeeded.
2265 */
2266static inline int peer_getline_version(struct appctx *appctx,
2267 unsigned int *maj_ver, unsigned int *min_ver)
2268{
2269 int reql;
2270
2271 reql = peer_getline(appctx);
2272 if (!reql)
2273 return 0;
2274
2275 if (reql < 0)
2276 return -1;
2277
2278 /* test protocol */
2279 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
2280 appctx->st0 = PEER_SESS_ST_EXIT;
2281 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2282 return -1;
2283 }
2284 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
2285 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
2286 appctx->st0 = PEER_SESS_ST_EXIT;
2287 appctx->st1 = PEER_SESS_SC_ERRVERSION;
2288 return -1;
2289 }
2290
2291 return 1;
2292}
2293
2294/*
2295 * Read and parse a second line of a "hello" peer protocol message.
2296 * Returns 0 if could not read a line, -1 if there was a read error or
2297 * the line is malformed, 1 if succeeded.
2298 */
2299static inline int peer_getline_host(struct appctx *appctx)
2300{
2301 int reql;
2302
2303 reql = peer_getline(appctx);
2304 if (!reql)
2305 return 0;
2306
2307 if (reql < 0)
2308 return -1;
2309
2310 /* test hostname match */
2311 if (strcmp(localpeer, trash.area) != 0) {
2312 appctx->st0 = PEER_SESS_ST_EXIT;
2313 appctx->st1 = PEER_SESS_SC_ERRHOST;
2314 return -1;
2315 }
2316
2317 return 1;
2318}
2319
2320/*
2321 * Read and parse a last line of a "hello" peer protocol message.
2322 * Returns 0 if could not read a character, -1 if there was a read error or
2323 * the line is malformed, 1 if succeeded.
2324 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2325 */
2326static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2327{
2328 char *p;
2329 int reql;
2330 struct peer *peer;
2331 struct stream_interface *si = appctx->owner;
2332 struct stream *s = si_strm(si);
2333 struct peers *peers = strm_fe(s)->parent;
2334
2335 reql = peer_getline(appctx);
2336 if (!reql)
2337 return 0;
2338
2339 if (reql < 0)
2340 return -1;
2341
2342 /* parse line "<peer name> <pid> <relative_pid>" */
2343 p = strchr(trash.area, ' ');
2344 if (!p) {
2345 appctx->st0 = PEER_SESS_ST_EXIT;
2346 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2347 return -1;
2348 }
2349 *p = 0;
2350
2351 /* lookup known peer */
2352 for (peer = peers->remote; peer; peer = peer->next) {
2353 if (strcmp(peer->id, trash.area) == 0)
2354 break;
2355 }
2356
2357 /* if unknown peer */
2358 if (!peer) {
2359 appctx->st0 = PEER_SESS_ST_EXIT;
2360 appctx->st1 = PEER_SESS_SC_ERRPEER;
2361 return -1;
2362 }
2363 *curpeer = peer;
2364
2365 return 1;
2366}
2367
2368/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002369 * Init <peer> peer after having accepted it at peer protocol level.
2370 */
2371static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2372{
2373 struct shared_table *st;
2374
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002375 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002376 /* Register status code */
2377 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002378 peer->last_hdshk = now_ms;
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002379
2380 /* Awake main task */
2381 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2382
2383 /* Init confirm counter */
2384 peer->confirm = 0;
2385
2386 /* Init cursors */
2387 for (st = peer->tables; st ; st = st->next) {
2388 st->last_get = st->last_acked = 0;
2389 st->teaching_origin = st->last_pushed = st->update;
2390 }
2391
2392 /* reset teaching and learning flags to 0 */
2393 peer->flags &= PEER_TEACH_RESET;
2394 peer->flags &= PEER_LEARN_RESET;
2395
2396 /* if current peer is local */
2397 if (peer->local) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002398 /* if current host need resyncfrom local and no process assigned */
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002399 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2400 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2401 /* assign local peer for a lesson, consider lesson already requested */
2402 peer->flags |= PEER_F_LEARN_ASSIGN;
2403 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2404 }
2405
2406 }
2407 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2408 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2409 /* assign peer for a lesson */
2410 peer->flags |= PEER_F_LEARN_ASSIGN;
2411 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2412 }
2413}
2414
2415/*
2416 * Init <peer> peer after having connected it at peer protocol level.
2417 */
2418static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2419{
2420 struct shared_table *st;
2421
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002422 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002423 /* Init cursors */
2424 for (st = peer->tables; st ; st = st->next) {
2425 st->last_get = st->last_acked = 0;
2426 st->teaching_origin = st->last_pushed = st->update;
2427 }
2428
2429 /* Init confirm counter */
2430 peer->confirm = 0;
2431
2432 /* reset teaching and learning flags to 0 */
2433 peer->flags &= PEER_TEACH_RESET;
2434 peer->flags &= PEER_LEARN_RESET;
2435
2436 /* If current peer is local */
2437 if (peer->local) {
2438 /* flag to start to teach lesson */
2439 peer->flags |= PEER_F_TEACH_PROCESS;
2440 }
2441 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2442 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2443 /* If peer is remote and resync from remote is needed,
2444 and no peer currently assigned */
2445
2446 /* assign peer for a lesson */
2447 peer->flags |= PEER_F_LEARN_ASSIGN;
2448 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2449 }
2450}
2451
2452/*
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002453 * IO Handler to handle message exchange with a peer
Emeric Brun2b920a12010-09-23 18:30:22 +02002454 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002455static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002456{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002457 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002458 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002459 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002460 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002461 int reql = 0;
2462 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002463 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002464 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002465
Joseph Herlant82b2f542018-11-15 12:19:14 -08002466 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002467 if (si_ic(si)->buf.size == 0) {
2468 si_rx_room_blk(si);
2469 goto out;
2470 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002471
Emeric Brun2b920a12010-09-23 18:30:22 +02002472 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002473 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002474switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002475 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002476 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002477 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002478 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002479 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002480 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002481 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002482 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002483 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002484 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2485 if (reql <= 0) {
2486 if (!reql)
2487 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002488 goto switchstate;
2489 }
2490
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002491 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002492 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002493 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002494 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002495 reql = peer_getline_host(appctx);
2496 if (reql <= 0) {
2497 if (!reql)
2498 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002499 goto switchstate;
2500 }
2501
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002502 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002503 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002504 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002505 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002506 reql = peer_getline_last(appctx, &curpeer);
2507 if (reql <= 0) {
2508 if (!reql)
2509 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002510 goto switchstate;
2511 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002512
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002513 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002514 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002515 if (curpeer->local) {
2516 /* Local connection, reply a retry */
2517 appctx->st0 = PEER_SESS_ST_EXIT;
2518 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2519 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002520 }
Emeric Brun80527f52017-06-19 17:46:37 +02002521
2522 /* we're killing a connection, we must apply a random delay before
2523 * retrying otherwise the other end will do the same and we can loop
2524 * for a while.
2525 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002526 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002527 peer_session_forceshutdown(curpeer);
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002528 curpeer->heartbeat = TICK_ETERNITY;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002529 curpeer->coll++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002530 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002531 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2532 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2533 curpeer->flags |= PEER_F_DWNGRD;
2534 }
2535 else {
2536 curpeer->flags &= ~PEER_F_DWNGRD;
2537 }
2538 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002539 curpeer->appctx = appctx;
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002540 curpeer->flags |= PEER_F_ALIVE;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002541 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002542 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002543 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002544 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002545 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002546 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002547 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002548 if (!curpeer) {
2549 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002550 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002551 if (curpeer->appctx != appctx) {
2552 appctx->st0 = PEER_SESS_ST_END;
2553 goto switchstate;
2554 }
2555 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002556
2557 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002558 if (repl <= 0) {
2559 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002560 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002561 goto switchstate;
2562 }
2563
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002564 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002565
Emeric Brun2b920a12010-09-23 18:30:22 +02002566 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002567 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002568 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002569 goto switchstate;
2570 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002571 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002572 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002573 if (!curpeer) {
2574 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002575 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002576 if (curpeer->appctx != appctx) {
2577 appctx->st0 = PEER_SESS_ST_END;
2578 goto switchstate;
2579 }
2580 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002581
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002582 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002583 if (repl <= 0) {
2584 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002585 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002586 goto switchstate;
2587 }
2588
2589 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002590 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002591 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002592 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002593 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002594 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002595 if (!curpeer) {
2596 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002597 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002598 if (curpeer->appctx != appctx) {
2599 appctx->st0 = PEER_SESS_ST_END;
2600 goto switchstate;
2601 }
2602 }
2603
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002604 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002605 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002606
Frédéric Lécaillece025572019-01-21 13:38:06 +01002607 reql = peer_getline(appctx);
2608 if (!reql)
2609 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002610
Frédéric Lécaillece025572019-01-21 13:38:06 +01002611 if (reql < 0)
2612 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002613
2614 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002615 curpeer->statuscode = atoi(trash.area);
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002616 curpeer->last_hdshk = now_ms;
Emeric Brun2b920a12010-09-23 18:30:22 +02002617
2618 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002619 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002620
2621 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002622 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002623 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002624 }
2625 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002626 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2627 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002628 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002629 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002630 goto switchstate;
2631 }
Olivier Houcharded879892019-03-08 18:53:43 +01002632 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002633 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002634 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002635 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002636 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002637 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002638 char *msg_cur = trash.area;
2639 char *msg_end = trash.area;
Willy Tarreaud4913912020-11-13 14:10:20 +01002640 unsigned char msg_head[7]; // 2 + 5 for varint32
Emeric Brun2b920a12010-09-23 18:30:22 +02002641 int totl = 0;
2642
Willy Tarreau2d372c22018-11-05 17:12:27 +01002643 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002644 if (!curpeer) {
2645 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002646 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002647 if (curpeer->appctx != appctx) {
2648 appctx->st0 = PEER_SESS_ST_END;
2649 goto switchstate;
2650 }
2651 }
2652
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002653 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2654 if (reql <= 0) {
2655 if (reql == -1)
2656 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002657 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002658 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002659
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002660 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002661 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002662 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002663
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002664 curpeer->flags |= PEER_F_ALIVE;
2665
Emeric Brun2b920a12010-09-23 18:30:22 +02002666 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002667 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002668 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002669 goto switchstate;
2670
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002671send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002672 if (curpeer->flags & PEER_F_HEARTBEAT) {
2673 curpeer->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002674 repl = peer_send_heartbeatmsg(appctx, curpeer, curpeers);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002675 if (repl <= 0) {
2676 if (repl == -1)
2677 goto out;
2678 goto switchstate;
2679 }
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002680 curpeer->tx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002681 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002682 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002683 repl = peer_send_msgs(appctx, curpeer, curpeers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002684 if (repl <= 0) {
2685 if (repl == -1)
2686 goto out;
2687 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002688 }
2689
Emeric Brun2b920a12010-09-23 18:30:22 +02002690 /* noting more to do */
2691 goto out;
2692 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002693 case PEER_SESS_ST_EXIT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002694 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002695 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002696 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002697 if (peer_send_status_errormsg(appctx) == -1)
2698 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002699 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002700 goto switchstate;
2701 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002702 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002703 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002704 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002705 if (peer_send_error_size_limitmsg(appctx) == -1)
2706 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002707 appctx->st0 = PEER_SESS_ST_END;
2708 goto switchstate;
2709 }
2710 case PEER_SESS_ST_ERRPROTO: {
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002711 TRACE_PROTO("protocol error", PEERS_EV_PROTOERR,
2712 NULL, curpeer, &prev_state);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002713 if (curpeer)
2714 curpeer->proto_err++;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002715 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002716 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002717 prev_state = appctx->st0;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002718 if (peer_send_error_protomsg(appctx) == -1) {
2719 TRACE_PROTO("could not send error message", PEERS_EV_PROTOERR);
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002720 goto out;
Frédéric Lécaille1cc0d9a2021-01-15 16:21:28 +01002721 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002722 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002723 prev_state = appctx->st0;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002724 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002725 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002726 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002727 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002728 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002729 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002730 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002731 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002732 curpeer = NULL;
2733 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002734 si_shutw(si);
2735 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002736 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002737 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002738 }
2739 }
2740 }
2741out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002742 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002743
2744 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002745 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002746 return;
2747}
2748
Willy Tarreau30576452015-04-13 13:50:30 +02002749static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002750 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002751 .name = "<PEER>", /* used for logging */
2752 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002753 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002754};
Emeric Brun2b920a12010-09-23 18:30:22 +02002755
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002756
Emeric Brun2b920a12010-09-23 18:30:22 +02002757/*
2758 * Use this function to force a close of a peer session
2759 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002760static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002761{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002762 struct appctx *appctx = peer->appctx;
2763
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002764 /* Note that the peer sessions which have just been created
2765 * (->st0 == PEER_SESS_ST_CONNECT) must not
2766 * be shutdown, if not, the TCP session will never be closed
2767 * and stay in CLOSE_WAIT state after having been closed by
2768 * the remote side.
2769 */
2770 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002771 return;
2772
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002773 if (appctx->applet != &peer_applet)
2774 return;
2775
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002776 __peer_session_deinit(peer);
2777
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002778 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002779 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002780}
2781
Willy Tarreau91d96282015-03-13 15:47:26 +01002782/* Pre-configures a peers frontend to accept incoming connections */
2783void peers_setup_frontend(struct proxy *fe)
2784{
2785 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002786 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002787 fe->mode = PR_MODE_PEERS;
Willy Tarreau91d96282015-03-13 15:47:26 +01002788 fe->maxconn = 0;
2789 fe->conn_retries = CONN_RETRIES;
2790 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002791 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002792 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002793 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002794 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002795}
2796
Emeric Brun2b920a12010-09-23 18:30:22 +02002797/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002798 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002799 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002800static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002801{
Willy Tarreau04b92862017-09-15 11:01:04 +02002802 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002803 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002804 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002805 struct stream *s;
Emeric Brun2b920a12010-09-23 18:30:22 +02002806
Frédéric Lécaille219587f2021-01-18 15:14:39 +01002807 peer->new_conn++;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002808 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002809 peer->heartbeat = TICK_ETERNITY;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002810 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002811 peer->last_hdshk = now_ms;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002812 s = NULL;
2813
Emeric Brun1138fd02017-06-19 12:38:55 +02002814 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002815 if (!appctx)
2816 goto out_close;
2817
2818 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002819 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002820
Willy Tarreau04b92862017-09-15 11:01:04 +02002821 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002822 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002823 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002824 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002825 }
2826
Willy Tarreau87787ac2017-08-28 16:22:54 +02002827 if ((s = stream_new(sess, &appctx->obj_type)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002828 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002829 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002830 }
2831
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002832 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002833 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002834 appctx_wakeup(appctx);
2835
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002836 /* initiate an outgoing connection */
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002837 s->target = peer_session_target(peer, s);
Willy Tarreau9b7587a2020-10-15 07:32:10 +02002838 if (!sockaddr_alloc(&s->target_addr, &peer->addr, sizeof(peer->addr)))
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002839 goto out_free_strm;
Willy Tarreau02efeda2019-07-18 17:21:24 +02002840 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Willy Tarreaudbd02672017-12-06 17:39:53 +01002841 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002842
Emeric Brun2b920a12010-09-23 18:30:22 +02002843 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002844 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002845
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002846 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002847
Emeric Brunb3971ab2015-05-12 18:49:09 +02002848 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002849 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002850 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002851 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002852
2853 /* Error unrolling */
Willy Tarreau15b5e142015-04-04 14:38:25 +02002854 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002855 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002856 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002857 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002858 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002859 out_free_appctx:
2860 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002861 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002862 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002863}
2864
2865/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002866 * Task processing function to manage re-connect, peer session
2867 * tasks wakeup on local update and heartbeat.
Emeric Brun2b920a12010-09-23 18:30:22 +02002868 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02002869static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002870{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002871 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002872 struct peer *ps;
2873 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002874
2875 task->expire = TICK_ETERNITY;
2876
Emeric Brunb3971ab2015-05-12 18:49:09 +02002877 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002878 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002879 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002880 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002881 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002882 return NULL;
2883 }
2884
Emeric Brun80527f52017-06-19 17:46:37 +02002885 /* Acquire lock for all peers of the section */
2886 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002887 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002888
Emeric Brun2b920a12010-09-23 18:30:22 +02002889 if (!stopping) {
2890 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002891
2892 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2893 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2894 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002895 /* Resync from local peer needed
2896 no peer was assigned for the lesson
2897 and no old local peer found
2898 or resync timeout expire */
2899
2900 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002901 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002902
2903 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002904 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002905 }
2906
2907 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002908 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002909 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002910 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002911 if (!ps->appctx) {
2912 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002913 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002914 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002915 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002916 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002917 tick_is_expired(ps->reconnect, now_ms))) {
2918 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002919 * or previous peer connection established with success
2920 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002921 * and reconnection timer is expired */
2922
2923 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002924 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002925 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002926 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002927 /* If previous session failed during connection
2928 * but reconnection timer is not expired */
2929
2930 /* reschedule task for reconnect */
2931 task->expire = tick_first(task->expire, ps->reconnect);
2932 }
2933 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002934 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002935 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002936 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002937 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2938 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002939 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2940 /* Resync from a remote is needed
2941 * and no peer was assigned for lesson
2942 * and current peer may be up2date */
2943
2944 /* assign peer for the lesson */
2945 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002946 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002947
Willy Tarreau9df94c22016-10-31 18:42:52 +01002948 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002949 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002950 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002951 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002952 int update_to_push = 0;
2953
Emeric Brunb3971ab2015-05-12 18:49:09 +02002954 /* Awake session if there is data to push */
2955 for (st = ps->tables; st ; st = st->next) {
2956 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002957 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002958 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002959 /* There is no need to send a heartbeat message
2960 * when some updates must be pushed. The remote
2961 * peer will consider <ps> peer as alive when it will
2962 * receive these updates.
2963 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002964 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002965 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002966 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002967 /* We are going to send updates, let's ensure we will
2968 * come back to send heartbeat messages or to reconnect.
2969 */
2970 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002971 appctx_wakeup(ps->appctx);
2972 break;
2973 }
2974 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002975 /* When there are updates to send we do not reconnect
2976 * and do not send heartbeat message either.
2977 */
2978 if (!update_to_push) {
2979 if (tick_is_expired(ps->reconnect, now_ms)) {
2980 if (ps->flags & PEER_F_ALIVE) {
2981 /* This peer was alive during a 'reconnect' period.
2982 * Flag it as not alive again for the next period.
2983 */
2984 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002985 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002986 }
2987 else {
Willy Tarreau52bf8392020-03-08 00:42:37 +01002988 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002989 ps->heartbeat = TICK_ETERNITY;
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002990 peer_session_forceshutdown(ps);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002991 ps->no_hbt++;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002992 }
2993 }
2994 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2995 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
2996 ps->flags |= PEER_F_HEARTBEAT;
2997 appctx_wakeup(ps->appctx);
2998 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01002999 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01003000 }
Emeric Brun2b920a12010-09-23 18:30:22 +02003001 }
3002 /* else do nothing */
3003 } /* SUCCESSCODE */
3004 } /* !ps->peer->local */
3005 } /* for */
3006
3007 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003008 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
3009 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
3010 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003011 /* Resync from remote peer needed
3012 * no peer was assigned for the lesson
3013 * and resync timeout expire */
3014
3015 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003016 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02003017 }
3018
Emeric Brunb3971ab2015-05-12 18:49:09 +02003019 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003020 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02003021 /* reschedule task to resync timeout if not expired, to ended resync if needed */
3022 if (!tick_is_expired(peers->resync_timeout, now_ms))
3023 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02003024 }
3025 } /* !stopping */
3026 else {
3027 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01003028 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08003029 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003030 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003031 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01003032 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003033 peers->flags |= PEERS_F_DONOTSTOP;
3034 ps = peers->local;
3035 for (st = ps->tables; st ; st = st->next)
3036 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02003037 }
3038
3039 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003040 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02003041 /* we're killing a connection, we must apply a random delay before
3042 * retrying otherwise the other end will do the same and we can loop
3043 * for a while.
3044 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01003045 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01003046 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02003047 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02003048 }
3049 }
3050 }
Emeric Brun2b920a12010-09-23 18:30:22 +02003051
Emeric Brunb3971ab2015-05-12 18:49:09 +02003052 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02003053 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02003054 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003055 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01003056 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003057 peers->flags &= ~PEERS_F_DONOTSTOP;
3058 for (st = ps->tables; st ; st = st->next)
3059 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02003060 }
3061 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01003062 else if (!ps->appctx) {
3063 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02003064 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01003065 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
3066 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
3067 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003068 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01003069 * or previous peer connection was successfully established
3070 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02003071 * or during previous connect, peer replies a try again statuscode */
3072
3073 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003074 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02003075 }
3076 else {
3077 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003078 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003079 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01003080 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003081 peers->flags &= ~PEERS_F_DONOTSTOP;
3082 for (st = ps->tables; st ; st = st->next)
3083 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02003084 }
3085 }
3086 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02003087 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01003088 /* current peer connection is active and established
3089 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003090 for (st = ps->tables; st ; st = st->next) {
3091 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02003092 appctx_wakeup(ps->appctx);
3093 break;
3094 }
3095 }
Emeric Brun2b920a12010-09-23 18:30:22 +02003096 }
3097 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02003098
3099 /* Release lock for all peers of the section */
3100 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003101 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02003102
Emeric Brun2b920a12010-09-23 18:30:22 +02003103 /* Wakeup for re-connect */
3104 return task;
3105}
3106
Emeric Brunb3971ab2015-05-12 18:49:09 +02003107
Emeric Brun2b920a12010-09-23 18:30:22 +02003108/*
Willy Tarreaud9443442018-10-15 11:18:03 +02003109 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02003110 */
Willy Tarreaud9443442018-10-15 11:18:03 +02003111int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02003112{
Emeric Brun2b920a12010-09-23 18:30:22 +02003113 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02003114
Emeric Brun2b920a12010-09-23 18:30:22 +02003115 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003116 peers->peers_fe->maxconn += 3;
3117 }
3118
Emeric Brunc60def82017-09-27 14:59:38 +02003119 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02003120 if (!peers->sync_task)
3121 return 0;
3122
Emeric Brunb3971ab2015-05-12 18:49:09 +02003123 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02003124 peers->sync_task->context = (void *)peers;
3125 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
3126 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02003127 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02003128}
3129
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003130/*
3131 * Allocate a cache a dictionary entries used upon transmission.
3132 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003133static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003134{
3135 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003136 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003137
3138 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003139 entries = calloc(max_entries, sizeof *entries);
3140 if (!d || !entries)
3141 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003142
3143 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02003144 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003145 d->cached_entries = EB_ROOT_UNIQUE;
3146 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003147
3148 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003149
3150 err:
3151 free(d);
3152 free(entries);
3153 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003154}
3155
3156/*
3157 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
3158 * as maximum of entries.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05003159 * Return the dictionary cache if succeeded, NULL if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003160 * Must be deallocated calling free_dcache().
3161 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003162static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003163{
3164 struct dcache_tx *dc_tx;
3165 struct dcache *dc;
3166 struct dcache_rx *dc_rx;
3167
3168 dc = calloc(1, sizeof *dc);
3169 dc_tx = new_dcache_tx(max_entries);
3170 dc_rx = calloc(max_entries, sizeof *dc_rx);
3171 if (!dc || !dc_tx || !dc_rx)
3172 goto err;
3173
3174 dc->tx = dc_tx;
3175 dc->rx = dc_rx;
3176 dc->max_entries = max_entries;
3177
3178 return dc;
3179
3180 err:
3181 free(dc);
3182 free(dc_tx);
3183 free(dc_rx);
3184 return NULL;
3185}
3186
3187/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003188 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
3189 * entries used upon transmission.
3190 * Return the entry if found, NULL if not.
3191 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003192static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
3193 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003194{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003195 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003196}
3197
3198/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003199 * Flush <dc> cache.
3200 * Always succeeds.
3201 */
3202static inline void flush_dcache(struct peer *peer)
3203{
3204 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003205 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003206
Frédéric Lécaille9650ee92020-11-12 21:01:54 +01003207 for (i = 0; i < dc->max_entries; i++) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003208 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécaille9650ee92020-11-12 21:01:54 +01003209 dc->tx->entries[i].key = NULL;
3210 }
3211 dc->tx->prev_lookup = NULL;
3212 dc->tx->lru_key = 0;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003213
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003214 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003215}
3216
3217/*
3218 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
3219 * with information provided by <i> dictionary cache entry (especially the value
3220 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003221 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003222 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003223static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003224{
3225 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003226 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003227
3228 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02003229
3230 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
3231 o = dc_tx->prev_lookup;
3232 } else {
3233 o = dcache_tx_lookup_value(dc_tx, i);
3234 if (o) {
3235 /* Save it */
3236 dc_tx->prev_lookup = o;
3237 }
3238 }
3239
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003240 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003241 /* Copy the ID. */
3242 i->id = o - dc->tx->entries;
3243 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003244 }
3245
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003246 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02003247 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003248
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003249 ebpt_delete(o);
3250 o->key = i->entry.key;
3251 ebpt_insert(&dc_tx->cached_entries, o);
3252 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003253
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003254 /* Update the index for the next entry to put in cache */
3255 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003256
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003257 return o;
3258}
Emeric Brunb3971ab2015-05-12 18:49:09 +02003259
3260/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003261 * Allocate a dictionary cache for each peer of <peers> section.
3262 * Return 1 if succeeded, 0 if not.
3263 */
3264int peers_alloc_dcache(struct peers *peers)
3265{
3266 struct peer *p;
3267
3268 for (p = peers->remote; p; p = p->next) {
3269 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
3270 if (!p->dcache)
3271 return 0;
3272 }
3273
3274 return 1;
3275}
3276
3277/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02003278 * Function used to register a table for sync on a group of peers
3279 *
3280 */
3281void peers_register_table(struct peers *peers, struct stktable *table)
3282{
3283 struct shared_table *st;
3284 struct peer * curpeer;
3285 int id = 0;
3286
3287 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003288 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003289 st->table = table;
3290 st->next = curpeer->tables;
3291 if (curpeer->tables)
3292 id = curpeer->tables->local_id;
3293 st->local_id = id + 1;
3294
3295 curpeer->tables = st;
3296 }
3297
3298 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003299}
3300
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003301/*
3302 * Parse the "show peers" command arguments.
3303 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3304 * error message.
3305 */
3306static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3307{
3308 appctx->ctx.cfgpeers.target = NULL;
3309
3310 if (*args[2]) {
3311 struct peers *p;
3312
3313 for (p = cfg_peers; p; p = p->next) {
3314 if (!strcmp(p->id, args[2])) {
3315 appctx->ctx.cfgpeers.target = p;
3316 break;
3317 }
3318 }
3319
Willy Tarreau9d008692019-08-09 11:21:01 +02003320 if (!p)
3321 return cli_err(appctx, "No such peers\n");
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003322 }
3323
3324 return 0;
3325}
3326
3327/*
3328 * This function dumps the peer state information of <peers> "peers" section.
3329 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3330 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3331 */
3332static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3333{
3334 struct tm tm;
3335
3336 get_localtime(peers->last_change, &tm);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003337 chunk_appendf(msg, "%p: [%02d/%s/%04d:%02d:%02d:%02d] id=%s disabled=%d flags=0x%x resync_timeout=%s task_calls=%u\n",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003338 peers,
3339 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3340 tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003341 peers->id, peers->disabled, peers->flags,
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003342 peers->resync_timeout ?
3343 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3344 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003345 TICKS_TO_MS(1000)) : "<NEVER>",
3346 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003347
3348 if (ci_putchk(si_ic(si), msg) == -1) {
3349 si_rx_room_blk(si);
3350 return 0;
3351 }
3352
3353 return 1;
3354}
3355
3356/*
3357 * This function dumps <peer> state information.
3358 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3359 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3360 */
3361static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3362{
3363 struct connection *conn;
3364 char pn[INET6_ADDRSTRLEN];
3365 struct stream_interface *peer_si;
3366 struct stream *peer_s;
3367 struct appctx *appctx;
3368 struct shared_table *st;
3369
3370 addr_to_str(&peer->addr, pn, sizeof pn);
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003371 chunk_appendf(msg, " %p: id=%s(%s,%s) addr=%s:%d last_status=%s",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003372 peer, peer->id,
3373 peer->local ? "local" : "remote",
Frédéric Lécaillee7e2b212020-10-05 12:33:07 +02003374 peer->appctx ? "active" : "inactive",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003375 pn, get_host_port(&peer->addr),
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003376 statuscode_str(peer->statuscode));
3377
3378 chunk_appendf(msg, " last_hdshk=%s\n",
3379 peer->last_hdshk ? human_time(TICKS_TO_MS(now_ms - peer->last_hdshk),
3380 TICKS_TO_MS(1000)) : "<NEVER>");
3381
3382 chunk_appendf(msg, " reconnect=%s",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003383 peer->reconnect ?
3384 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3385 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003386 TICKS_TO_MS(1000)) : "<NEVER>");
3387
3388 chunk_appendf(msg, " heartbeat=%s",
3389 peer->heartbeat ?
3390 tick_is_expired(peer->heartbeat, now_ms) ? "<PAST>" :
3391 human_time(TICKS_TO_MS(peer->heartbeat - now_ms),
3392 TICKS_TO_MS(1000)) : "<NEVER>");
3393
3394 chunk_appendf(msg, " confirm=%u tx_hbt=%u rx_hbt=%u no_hbt=%u new_conn=%u proto_err=%u coll=%u\n",
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003395 peer->confirm, peer->tx_hbt, peer->rx_hbt,
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003396 peer->no_hbt, peer->new_conn, peer->proto_err, peer->coll);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003397
3398 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3399
3400 appctx = peer->appctx;
3401 if (!appctx)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003402 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003403
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003404 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3405 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003406
3407 peer_si = peer->appctx->owner;
3408 if (!peer_si)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003409 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003410
3411 peer_s = si_strm(peer_si);
3412 if (!peer_s)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003413 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003414
3415 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3416
3417 conn = objt_conn(strm_orig(peer_s));
3418 if (conn)
3419 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3420
Willy Tarreau3ca14902019-07-17 14:53:15 +02003421 switch (conn && conn_get_src(conn) ? addr_to_str(conn->src, pn, sizeof(pn)) : AF_UNSPEC) {
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003422 case AF_INET:
3423 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003424 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(conn->src));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003425 break;
3426 case AF_UNIX:
3427 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3428 break;
3429 }
3430
Willy Tarreau3ca14902019-07-17 14:53:15 +02003431 switch (conn && conn_get_dst(conn) ? addr_to_str(conn->dst, pn, sizeof(pn)) : AF_UNSPEC) {
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003432 case AF_INET:
3433 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003434 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(conn->dst));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003435 break;
3436 case AF_UNIX:
3437 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3438 break;
3439 }
3440
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003441 table_info:
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003442 if (peer->remote_table)
3443 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3444 peer->remote_table,
3445 peer->remote_table->table->id,
3446 peer->remote_table->local_id,
3447 peer->remote_table->remote_id);
3448
3449 if (peer->last_local_table)
3450 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3451 peer->last_local_table,
3452 peer->last_local_table->table->id,
3453 peer->last_local_table->local_id,
3454 peer->last_local_table->remote_id);
3455
3456 if (peer->tables) {
3457 chunk_appendf(&trash, "\n shared tables:");
3458 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003459 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003460 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003461 struct dcache *dcache;
3462
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003463 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003464 dcache = peer->dcache;
3465
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003466 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3467 "flags=0x%x remote_data=0x%llx",
3468 st, st->local_id, st->remote_id,
3469 st->flags, (unsigned long long)st->remote_data);
3470 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3471 " teaching_origin=%u update=%u",
3472 st->last_acked, st->last_pushed, st->last_get,
3473 st->teaching_origin, st->update);
3474 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3475 " commitupdate=%u syncing=%u",
3476 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003477 chunk_appendf(&trash, "\n TX dictionary cache:");
3478 count = 0;
3479 for (i = 0; i < dcache->max_entries; i++) {
3480 struct ebpt_node *node;
3481 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003482
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003483 node = &dcache->tx->entries[i];
3484 if (!node->key)
3485 break;
3486
3487 if (!count++)
3488 chunk_appendf(&trash, "\n ");
3489 de = node->key;
3490 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3491 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003492 }
3493 chunk_appendf(&trash, "\n RX dictionary cache:");
3494 count = 0;
3495 for (i = 0; i < dcache->max_entries; i++) {
3496 if (!count++)
3497 chunk_appendf(&trash, "\n ");
3498 chunk_appendf(&trash, " %3u -> %s", i,
3499 dcache->rx[i].de ?
3500 (char *)dcache->rx[i].de->value.key : "-");
3501 count &= 0x3;
3502 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003503 }
3504 }
3505
3506 end:
3507 chunk_appendf(&trash, "\n");
3508 if (ci_putchk(si_ic(si), msg) == -1) {
3509 si_rx_room_blk(si);
3510 return 0;
3511 }
3512
3513 return 1;
3514}
3515
3516/*
3517 * This function dumps all the peers of "peers" section.
3518 * Returns 0 if the output buffer is full and needs to be called
3519 * again, non-zero if not. It proceeds in an isolated thread, so
3520 * there is no thread safety issue here.
3521 */
3522static int cli_io_handler_show_peers(struct appctx *appctx)
3523{
3524 int show_all;
3525 int ret = 0, first_peers = 1;
3526 struct stream_interface *si = appctx->owner;
3527
3528 thread_isolate();
3529
3530 show_all = !appctx->ctx.cfgpeers.target;
3531
3532 chunk_reset(&trash);
3533
3534 while (appctx->st2 != STAT_ST_FIN) {
3535 switch (appctx->st2) {
3536 case STAT_ST_INIT:
3537 if (show_all)
3538 appctx->ctx.cfgpeers.peers = cfg_peers;
3539 else
3540 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3541
3542 appctx->st2 = STAT_ST_LIST;
3543 /* fall through */
3544
3545 case STAT_ST_LIST:
3546 if (!appctx->ctx.cfgpeers.peers) {
3547 /* No more peers list. */
3548 appctx->st2 = STAT_ST_END;
3549 }
3550 else {
3551 if (!first_peers)
3552 chunk_appendf(&trash, "\n");
3553 else
3554 first_peers = 0;
3555 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3556 goto out;
3557
3558 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3559 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3560 appctx->st2 = STAT_ST_INFO;
3561 }
3562 break;
3563
3564 case STAT_ST_INFO:
3565 if (!appctx->ctx.cfgpeers.peer) {
3566 /* End of peer list */
3567 if (show_all)
3568 appctx->st2 = STAT_ST_LIST;
3569 else
3570 appctx->st2 = STAT_ST_END;
3571 }
3572 else {
3573 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3574 goto out;
3575
3576 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3577 }
3578 break;
3579
3580 case STAT_ST_END:
3581 appctx->st2 = STAT_ST_FIN;
3582 break;
3583 }
3584 }
3585 ret = 1;
3586 out:
3587 thread_release();
3588 return ret;
3589}
3590
3591/*
3592 * CLI keywords.
3593 */
3594static struct cli_kw_list cli_kws = {{ }, {
3595 { { "show", "peers", NULL }, "show peers [peers section]: dump some information about all the peers or this peers section", cli_parse_show_peers, cli_io_handler_show_peers, },
3596 {},
3597}};
3598
3599/* Register cli keywords */
3600INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3601