blob: a4854f4638e4798b9bec775cfaea2554469a7904 [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écailled8659352020-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écailled8659352020-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écailleda2b0842021-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écailled8659352020-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écailleda2b0842021-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écailled8659352020-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écailleda2b0842021-01-15 16:21:28 +0100367 if (mask & (PEERS_EV_UPDTMSG|PEERS_EV_ACKMSG|PEERS_EV_SWTCMSG)) {
Frédéric Lécailled8659352020-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écailleda2b0842021-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écaille4b1a05f2021-01-17 13:08:39 +0100428 if (peer && peer->appctx) {
Frédéric Lécailleda2b0842021-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écailled8659352020-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écailleda2b0842021-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écailleda2b0842021-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écailleda2b0842021-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écailleda2b0842021-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écailleda2b0842021-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écailleda2b0842021-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écailleda2b0842021-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écailleda2b0842021-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écailleda2b0842021-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écailled8659352020-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écaillef9e51be2020-11-12 19:53:11 +01001727 if (id > dc->max_entries) {
1728 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1729 NULL, p, NULL, &id);
1730 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écailled8659352020-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écailled8659352020-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
Thayne McCombs92149f92020-11-20 01:28:26 -07001751 de = dict_insert(&server_key_dict, chunk->area);
1752 dict_entry_unref(&server_key_dict, dc->rx[id - 1].de);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001753 dc->rx[id - 1].de = de;
1754 }
1755 if (de) {
1756 data_ptr = stktable_data_ptr(st->table, ts, data_type);
Thayne McCombs92149f92020-11-20 01:28:26 -07001757 if (data_ptr) {
1758 HA_ATOMIC_ADD(&de->refcount, 1);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001759 stktable_data_cast(data_ptr, std_t_dict) = de;
Thayne McCombs92149f92020-11-20 01:28:26 -07001760 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001761 }
1762 break;
1763 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001764 }
1765 }
1766 /* Force new expiration */
1767 ts->expire = tick_add(now_ms, expire);
1768
1769 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1770 stktable_touch_remote(st->table, ts, 1);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001771 TRACE_LEAVE(PEERS_EV_UPDTMSG, NULL, p);
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001772 return 1;
1773
1774 ignore_msg:
1775 /* skip consumed message */
1776 co_skip(si_oc(si), totl);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001777 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001778 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001779
1780 malformed_unlock:
1781 /* malformed message */
1782 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1783 stktable_touch_remote(st->table, ts, 1);
1784 appctx->st0 = PEER_SESS_ST_ERRPROTO;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001785 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001786 return 0;
1787
1788 malformed_free_newts:
1789 /* malformed message */
1790 stksess_free(st->table, newts);
1791 malformed_exit:
1792 appctx->st0 = PEER_SESS_ST_ERRPROTO;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001793 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001794 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001795}
1796
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001797/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001798 * Function used to parse a stick-table update acknowledgement message after it
1799 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1800 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1801 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1802 * was encountered.
1803 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1804 */
1805static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1806 char **msg_cur, char *msg_end)
1807{
1808 /* ack message */
1809 uint32_t table_id ;
1810 uint32_t update;
1811 struct shared_table *st;
1812
1813 table_id = intdecode(msg_cur, msg_end);
1814 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1815 /* malformed message */
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001816
1817 TRACE_PROTO("malformed message", PEERS_EV_ACKMSG,
1818 NULL, p, *msg_cur);
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001819 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1820 return 0;
1821 }
1822
1823 memcpy(&update, *msg_cur, sizeof(update));
1824 update = ntohl(update);
1825
1826 for (st = p->tables; st; st = st->next) {
1827 if (st->local_id == table_id) {
1828 st->update = update;
1829 break;
1830 }
1831 }
1832
1833 return 1;
1834}
1835
1836/*
1837 * Function used to parse a stick-table switch message after it has been received
1838 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1839 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1840 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1841 * was encountered.
1842 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1843 */
1844static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1845 char **msg_cur, char *msg_end)
1846{
1847 struct shared_table *st;
1848 int table_id;
1849
1850 table_id = intdecode(msg_cur, msg_end);
1851 if (!*msg_cur) {
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001852 TRACE_PROTO("malformed message", PEERS_EV_SWTCMSG, NULL, p);
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001853 /* malformed message */
1854 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1855 return 0;
1856 }
1857
1858 p->remote_table = NULL;
1859 for (st = p->tables; st; st = st->next) {
1860 if (st->remote_id == table_id) {
1861 p->remote_table = st;
1862 break;
1863 }
1864 }
1865
1866 return 1;
1867}
1868
1869/*
1870 * Function used to parse a stick-table definition message after it has been received
1871 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1872 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1873 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1874 * was encountered.
1875 * <totl> is the length of the stick-table update message computed upon receipt.
1876 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1877 */
1878static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1879 char **msg_cur, char *msg_end, int totl)
1880{
1881 struct stream_interface *si = appctx->owner;
1882 int table_id_len;
1883 struct shared_table *st;
1884 int table_type;
1885 int table_keylen;
1886 int table_id;
1887 uint64_t table_data;
1888
1889 table_id = intdecode(msg_cur, msg_end);
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001890 if (!*msg_cur) {
1891 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001892 goto malformed_exit;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001893 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001894
1895 table_id_len = intdecode(msg_cur, msg_end);
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001896 if (!*msg_cur) {
1897 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p, *msg_cur);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001898 goto malformed_exit;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001899 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001900
1901 p->remote_table = NULL;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001902 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end) {
1903 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p, *msg_cur, &table_id_len);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001904 goto malformed_exit;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001905 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001906
1907 for (st = p->tables; st; st = st->next) {
1908 /* Reset IDs */
1909 if (st->remote_id == table_id)
1910 st->remote_id = 0;
1911
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001912 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1913 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001914 p->remote_table = st;
1915 }
1916
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001917 if (!p->remote_table) {
1918 TRACE_PROTO("ignored message", PEERS_EV_DEFMSG, NULL, p);
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001919 goto ignore_msg;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001920 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001921
1922 *msg_cur += table_id_len;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001923 if (*msg_cur >= msg_end) {
1924 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001925 goto malformed_exit;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001926 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001927
1928 table_type = intdecode(msg_cur, msg_end);
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001929 if (!*msg_cur) {
1930 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001931 goto malformed_exit;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001932 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001933
1934 table_keylen = intdecode(msg_cur, msg_end);
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001935 if (!*msg_cur) {
1936 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001937 goto malformed_exit;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001938 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001939
1940 table_data = intdecode(msg_cur, msg_end);
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001941 if (!*msg_cur) {
1942 TRACE_PROTO("malformed message", PEERS_EV_DEFMSG, NULL, p);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001943 goto malformed_exit;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001944 }
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001945
Emeric Brun530ba382020-06-02 11:17:42 +02001946 if (p->remote_table->table->type != peer_int_key_type[table_type]
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001947 || p->remote_table->table->key_size != table_keylen) {
1948 p->remote_table = NULL;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01001949 TRACE_PROTO("ignored message", PEERS_EV_DEFMSG, NULL, p);
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001950 goto ignore_msg;
1951 }
1952
1953 p->remote_table->remote_data = table_data;
1954 p->remote_table->remote_id = table_id;
1955 return 1;
1956
1957 ignore_msg:
1958 co_skip(si_oc(si), totl);
1959 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001960
1961 malformed_exit:
1962 /* malformed message */
1963 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1964 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001965}
1966
1967/*
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001968 * Receive a stick-table message or pre-parse any other message.
1969 * The message's header will be sent into <msg_head> which must be at least
1970 * <msg_head_sz> bytes long (at least 7 to store 32-bit variable lengths).
1971 * The first two bytes are always read, and the rest is only read if the
1972 * first bytes indicate a stick-table message. If the message is a stick-table
1973 * message, the varint is decoded and the equivalent number of bytes will be
1974 * copied into the trash at trash.area. <totl> is incremented by the number of
1975 * bytes read EVEN IN CASE OF INCOMPLETE MESSAGES.
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001976 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1977 * -1 if there was an error updating the appctx state st0 accordingly.
1978 */
1979static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1980 uint32_t *msg_len, int *totl)
1981{
1982 int reql;
1983 struct stream_interface *si = appctx->owner;
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001984 char *cur;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001985
1986 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1987 if (reql <= 0) /* closed or EOL not found */
1988 goto incomplete;
1989
1990 *totl += reql;
1991
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001992 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001993 return 1;
1994
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001995 /* This is a stick-table message, let's go on */
1996
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001997 /* Read and Decode message length */
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001998 msg_head += *totl;
1999 msg_head_sz -= *totl;
2000 reql = co_data(si_oc(si)) - *totl;
2001 if (reql > msg_head_sz)
2002 reql = msg_head_sz;
2003
2004 reql = co_getblk(si_oc(si), msg_head, reql, *totl);
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002005 if (reql <= 0) /* closed */
2006 goto incomplete;
2007
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01002008 cur = msg_head;
2009 *msg_len = intdecode(&cur, cur + reql);
2010 if (!cur) {
2011 /* the number is truncated, did we read enough ? */
2012 if (reql < msg_head_sz)
2013 goto incomplete;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002014
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01002015 /* malformed message */
2016 TRACE_PROTO("malformed message: too large length encoding", PEERS_EV_UPDTMSG);
2017 appctx->st0 = PEER_SESS_ST_ERRPROTO;
2018 return -1;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002019 }
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01002020 *totl += cur - msg_head;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002021
2022 /* Read message content */
2023 if (*msg_len) {
2024 if (*msg_len > trash.size) {
2025 /* Status code is not success, abort */
2026 appctx->st0 = PEER_SESS_ST_ERRSIZE;
2027 return -1;
2028 }
2029
2030 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
2031 if (reql <= 0) /* closed */
2032 goto incomplete;
2033 *totl += reql;
2034 }
2035
2036 return 1;
2037
2038 incomplete:
Willy Tarreau345ebcf2020-11-26 17:06:04 +01002039 if (reql < 0 || (si_oc(si)->flags & (CF_SHUTW|CF_SHUTW_NOW))) {
2040 /* there was an error or the message was truncated */
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002041 appctx->st0 = PEER_SESS_ST_END;
2042 return -1;
2043 }
2044
2045 return 0;
2046}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002047
2048/*
2049 * Treat the awaited message with <msg_head> as header.*
2050 * Return 1 if succeeded, 0 if not.
2051 */
2052static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
2053 char **msg_cur, char *msg_end, int msg_len, int totl)
2054{
2055 struct stream_interface *si = appctx->owner;
2056 struct stream *s = si_strm(si);
2057 struct peers *peers = strm_fe(s)->parent;
2058
2059 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
2060 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
2061 struct shared_table *st;
2062 /* Reset message: remote need resync */
2063
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002064 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2065 NULL, &msg_head[1], peers->local->id, peer->id);
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002066 /* prepare tables for a global push */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002067 for (st = peer->tables; st; st = st->next) {
2068 st->teaching_origin = st->last_pushed = st->table->update;
2069 st->flags = 0;
2070 }
2071
2072 /* reset teaching flags to 0 */
2073 peer->flags &= PEER_TEACH_RESET;
2074
2075 /* flag to start to teach lesson */
2076 peer->flags |= PEER_F_TEACH_PROCESS;
2077 }
2078 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002079 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2080 NULL, &msg_head[1], peers->local->id, peer->id);
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002081 if (peer->flags & PEER_F_LEARN_ASSIGN) {
2082 peer->flags &= ~PEER_F_LEARN_ASSIGN;
2083 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2084 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
2085 }
2086 peer->confirm++;
2087 }
2088 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002089 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2090 NULL, &msg_head[1], peers->local->id, peer->id);
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002091 if (peer->flags & PEER_F_LEARN_ASSIGN) {
2092 peer->flags &= ~PEER_F_LEARN_ASSIGN;
2093 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2094
2095 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002096 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002097 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2098 }
2099 peer->confirm++;
2100 }
2101 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
2102 struct shared_table *st;
2103
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002104 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2105 NULL, &msg_head[1], peers->local->id, peer->id);
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002106 /* If stopping state */
2107 if (stopping) {
2108 /* Close session, push resync no more needed */
2109 peer->flags |= PEER_F_TEACH_COMPLETE;
2110 appctx->st0 = PEER_SESS_ST_END;
2111 return 0;
2112 }
2113 for (st = peer->tables; st; st = st->next) {
2114 st->update = st->last_pushed = st->teaching_origin;
2115 st->flags = 0;
2116 }
2117
2118 /* reset teaching flags to 0 */
2119 peer->flags &= PEER_TEACH_RESET;
2120 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002121 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002122 TRACE_PROTO("received control message", PEERS_EV_CTRLMSG,
2123 NULL, &msg_head[1], peers->local->id, peer->id);
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002124 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002125 peer->rx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002126 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002127 }
2128 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
2129 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
2130 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
2131 return 0;
2132 }
2133 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
2134 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
2135 return 0;
2136 }
2137 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
2138 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
2139 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
2140 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
2141 int update, expire;
2142
2143 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
2144 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
2145 if (!peer_treat_updatemsg(appctx, peer, update, expire,
2146 msg_cur, msg_end, msg_len, totl))
2147 return 0;
2148
2149 }
2150 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
2151 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
2152 return 0;
2153 }
2154 }
2155 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
2156 appctx->st0 = PEER_SESS_ST_ERRPROTO;
2157 return 0;
2158 }
2159
2160 return 1;
2161}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002162
2163
2164/*
2165 * Send any message to <peer> peer.
2166 * Returns 1 if succeeded, or -1 or 0 if failed.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002167 * -1 means an internal error occurred, 0 is for a peer protocol error leading
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002168 * to a peer state change (from the peer I/O handler point of view).
2169 */
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002170static inline int peer_send_msgs(struct appctx *appctx,
2171 struct peer *peer, struct peers *peers)
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002172{
2173 int repl;
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002174
2175 /* Need to request a resync */
2176 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
2177 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2178 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
2179
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002180 repl = peer_send_resync_reqmsg(appctx, peer, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002181 if (repl <= 0)
2182 return repl;
2183
2184 peers->flags |= PEERS_F_RESYNC_PROCESS;
2185 }
2186
2187 /* Nothing to read, now we start to write */
2188 if (peer->tables) {
2189 struct shared_table *st;
2190 struct shared_table *last_local_table;
2191
2192 last_local_table = peer->last_local_table;
2193 if (!last_local_table)
2194 last_local_table = peer->tables;
2195 st = last_local_table->next;
2196
2197 while (1) {
2198 if (!st)
2199 st = peer->tables;
2200
2201 /* It remains some updates to ack */
2202 if (st->last_get != st->last_acked) {
2203 repl = peer_send_ackmsg(st, appctx);
2204 if (repl <= 0)
2205 return repl;
2206
2207 st->last_acked = st->last_get;
2208 }
2209
2210 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
2211 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
2212 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
2213 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
2214
2215 repl = peer_send_teach_process_msgs(appctx, peer, st);
2216 if (repl <= 0) {
2217 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
2218 return repl;
2219 }
2220 }
2221 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
2222 }
2223 else {
2224 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
2225 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
2226 if (repl <= 0)
2227 return repl;
2228 }
2229
2230 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
2231 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
2232 if (repl <= 0)
2233 return repl;
2234 }
2235 }
2236
2237 if (st == last_local_table)
2238 break;
2239 st = st->next;
2240 }
2241 }
2242
2243 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002244 repl = peer_send_resync_finishedmsg(appctx, peer, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002245 if (repl <= 0)
2246 return repl;
2247
2248 /* flag finished message sent */
2249 peer->flags |= PEER_F_TEACH_FINISHED;
2250 }
2251
2252 /* Confirm finished or partial messages */
2253 while (peer->confirm) {
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002254 repl = peer_send_resync_confirmsg(appctx, peer, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002255 if (repl <= 0)
2256 return repl;
2257
2258 peer->confirm--;
2259 }
2260
2261 return 1;
2262}
2263
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002264/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002265 * Read and parse a first line of a "hello" peer protocol message.
2266 * Returns 0 if could not read a line, -1 if there was a read error or
2267 * the line is malformed, 1 if succeeded.
2268 */
2269static inline int peer_getline_version(struct appctx *appctx,
2270 unsigned int *maj_ver, unsigned int *min_ver)
2271{
2272 int reql;
2273
2274 reql = peer_getline(appctx);
2275 if (!reql)
2276 return 0;
2277
2278 if (reql < 0)
2279 return -1;
2280
2281 /* test protocol */
2282 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
2283 appctx->st0 = PEER_SESS_ST_EXIT;
2284 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2285 return -1;
2286 }
2287 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
2288 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
2289 appctx->st0 = PEER_SESS_ST_EXIT;
2290 appctx->st1 = PEER_SESS_SC_ERRVERSION;
2291 return -1;
2292 }
2293
2294 return 1;
2295}
2296
2297/*
2298 * Read and parse a second line of a "hello" peer protocol message.
2299 * Returns 0 if could not read a line, -1 if there was a read error or
2300 * the line is malformed, 1 if succeeded.
2301 */
2302static inline int peer_getline_host(struct appctx *appctx)
2303{
2304 int reql;
2305
2306 reql = peer_getline(appctx);
2307 if (!reql)
2308 return 0;
2309
2310 if (reql < 0)
2311 return -1;
2312
2313 /* test hostname match */
2314 if (strcmp(localpeer, trash.area) != 0) {
2315 appctx->st0 = PEER_SESS_ST_EXIT;
2316 appctx->st1 = PEER_SESS_SC_ERRHOST;
2317 return -1;
2318 }
2319
2320 return 1;
2321}
2322
2323/*
2324 * Read and parse a last line of a "hello" peer protocol message.
2325 * Returns 0 if could not read a character, -1 if there was a read error or
2326 * the line is malformed, 1 if succeeded.
2327 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2328 */
2329static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2330{
2331 char *p;
2332 int reql;
2333 struct peer *peer;
2334 struct stream_interface *si = appctx->owner;
2335 struct stream *s = si_strm(si);
2336 struct peers *peers = strm_fe(s)->parent;
2337
2338 reql = peer_getline(appctx);
2339 if (!reql)
2340 return 0;
2341
2342 if (reql < 0)
2343 return -1;
2344
2345 /* parse line "<peer name> <pid> <relative_pid>" */
2346 p = strchr(trash.area, ' ');
2347 if (!p) {
2348 appctx->st0 = PEER_SESS_ST_EXIT;
2349 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2350 return -1;
2351 }
2352 *p = 0;
2353
2354 /* lookup known peer */
2355 for (peer = peers->remote; peer; peer = peer->next) {
2356 if (strcmp(peer->id, trash.area) == 0)
2357 break;
2358 }
2359
2360 /* if unknown peer */
2361 if (!peer) {
2362 appctx->st0 = PEER_SESS_ST_EXIT;
2363 appctx->st1 = PEER_SESS_SC_ERRPEER;
2364 return -1;
2365 }
2366 *curpeer = peer;
2367
2368 return 1;
2369}
2370
2371/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002372 * Init <peer> peer after having accepted it at peer protocol level.
2373 */
2374static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2375{
2376 struct shared_table *st;
2377
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002378 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002379 /* Register status code */
2380 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002381 peer->last_hdshk = now_ms;
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002382
2383 /* Awake main task */
2384 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2385
2386 /* Init confirm counter */
2387 peer->confirm = 0;
2388
2389 /* Init cursors */
2390 for (st = peer->tables; st ; st = st->next) {
2391 st->last_get = st->last_acked = 0;
2392 st->teaching_origin = st->last_pushed = st->update;
2393 }
2394
2395 /* reset teaching and learning flags to 0 */
2396 peer->flags &= PEER_TEACH_RESET;
2397 peer->flags &= PEER_LEARN_RESET;
2398
2399 /* if current peer is local */
2400 if (peer->local) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002401 /* if current host need resyncfrom local and no process assigned */
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002402 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2403 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2404 /* assign local peer for a lesson, consider lesson already requested */
2405 peer->flags |= PEER_F_LEARN_ASSIGN;
2406 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2407 }
2408
2409 }
2410 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2411 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2412 /* assign peer for a lesson */
2413 peer->flags |= PEER_F_LEARN_ASSIGN;
2414 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2415 }
2416}
2417
2418/*
2419 * Init <peer> peer after having connected it at peer protocol level.
2420 */
2421static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2422{
2423 struct shared_table *st;
2424
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002425 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002426 /* Init cursors */
2427 for (st = peer->tables; st ; st = st->next) {
2428 st->last_get = st->last_acked = 0;
2429 st->teaching_origin = st->last_pushed = st->update;
2430 }
2431
2432 /* Init confirm counter */
2433 peer->confirm = 0;
2434
2435 /* reset teaching and learning flags to 0 */
2436 peer->flags &= PEER_TEACH_RESET;
2437 peer->flags &= PEER_LEARN_RESET;
2438
2439 /* If current peer is local */
2440 if (peer->local) {
2441 /* flag to start to teach lesson */
2442 peer->flags |= PEER_F_TEACH_PROCESS;
2443 }
2444 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2445 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2446 /* If peer is remote and resync from remote is needed,
2447 and no peer currently assigned */
2448
2449 /* assign peer for a lesson */
2450 peer->flags |= PEER_F_LEARN_ASSIGN;
2451 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2452 }
2453}
2454
2455/*
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002456 * IO Handler to handle message exchange with a peer
Emeric Brun2b920a12010-09-23 18:30:22 +02002457 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002458static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002459{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002460 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002461 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002462 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002463 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002464 int reql = 0;
2465 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002466 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002467 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002468
Joseph Herlant82b2f542018-11-15 12:19:14 -08002469 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002470 if (si_ic(si)->buf.size == 0) {
2471 si_rx_room_blk(si);
2472 goto out;
2473 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002474
Emeric Brun2b920a12010-09-23 18:30:22 +02002475 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002476 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002477switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002478 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002479 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002480 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002481 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002482 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002483 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002484 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002485 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002486 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002487 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2488 if (reql <= 0) {
2489 if (!reql)
2490 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002491 goto switchstate;
2492 }
2493
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002494 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002495 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002496 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002497 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002498 reql = peer_getline_host(appctx);
2499 if (reql <= 0) {
2500 if (!reql)
2501 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002502 goto switchstate;
2503 }
2504
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002505 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002506 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002507 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002508 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002509 reql = peer_getline_last(appctx, &curpeer);
2510 if (reql <= 0) {
2511 if (!reql)
2512 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002513 goto switchstate;
2514 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002515
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002516 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002517 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002518 if (curpeer->local) {
2519 /* Local connection, reply a retry */
2520 appctx->st0 = PEER_SESS_ST_EXIT;
2521 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2522 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002523 }
Emeric Brun80527f52017-06-19 17:46:37 +02002524
2525 /* we're killing a connection, we must apply a random delay before
2526 * retrying otherwise the other end will do the same and we can loop
2527 * for a while.
2528 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002529 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002530 peer_session_forceshutdown(curpeer);
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002531 curpeer->heartbeat = TICK_ETERNITY;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002532 curpeer->coll++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002533 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002534 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2535 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2536 curpeer->flags |= PEER_F_DWNGRD;
2537 }
2538 else {
2539 curpeer->flags &= ~PEER_F_DWNGRD;
2540 }
2541 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002542 curpeer->appctx = appctx;
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002543 curpeer->flags |= PEER_F_ALIVE;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002544 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002545 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002546 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002547 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002548 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002549 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002550 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002551 if (!curpeer) {
2552 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002553 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002554 if (curpeer->appctx != appctx) {
2555 appctx->st0 = PEER_SESS_ST_END;
2556 goto switchstate;
2557 }
2558 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002559
2560 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002561 if (repl <= 0) {
2562 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002563 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002564 goto switchstate;
2565 }
2566
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002567 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002568
Emeric Brun2b920a12010-09-23 18:30:22 +02002569 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002570 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002571 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002572 goto switchstate;
2573 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002574 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002575 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002576 if (!curpeer) {
2577 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002578 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002579 if (curpeer->appctx != appctx) {
2580 appctx->st0 = PEER_SESS_ST_END;
2581 goto switchstate;
2582 }
2583 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002584
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002585 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002586 if (repl <= 0) {
2587 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002588 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002589 goto switchstate;
2590 }
2591
2592 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002593 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002594 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002595 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002596 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002597 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002598 if (!curpeer) {
2599 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002600 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002601 if (curpeer->appctx != appctx) {
2602 appctx->st0 = PEER_SESS_ST_END;
2603 goto switchstate;
2604 }
2605 }
2606
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002607 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002608 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002609
Frédéric Lécaillece025572019-01-21 13:38:06 +01002610 reql = peer_getline(appctx);
2611 if (!reql)
2612 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002613
Frédéric Lécaillece025572019-01-21 13:38:06 +01002614 if (reql < 0)
2615 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002616
2617 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002618 curpeer->statuscode = atoi(trash.area);
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002619 curpeer->last_hdshk = now_ms;
Emeric Brun2b920a12010-09-23 18:30:22 +02002620
2621 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002622 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002623
2624 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002625 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002626 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002627 }
2628 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002629 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2630 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002631 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002632 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002633 goto switchstate;
2634 }
Olivier Houcharded879892019-03-08 18:53:43 +01002635 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002636 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002637 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002638 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002639 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002640 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002641 char *msg_cur = trash.area;
2642 char *msg_end = trash.area;
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01002643 unsigned char msg_head[7]; // 2 + 5 for varint32
Emeric Brun2b920a12010-09-23 18:30:22 +02002644 int totl = 0;
2645
Willy Tarreau2d372c22018-11-05 17:12:27 +01002646 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002647 if (!curpeer) {
2648 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002649 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002650 if (curpeer->appctx != appctx) {
2651 appctx->st0 = PEER_SESS_ST_END;
2652 goto switchstate;
2653 }
2654 }
2655
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002656 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2657 if (reql <= 0) {
2658 if (reql == -1)
2659 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002660 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002661 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002662
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002663 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002664 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002665 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002666
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002667 curpeer->flags |= PEER_F_ALIVE;
2668
Emeric Brun2b920a12010-09-23 18:30:22 +02002669 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002670 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002671 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002672 goto switchstate;
2673
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002674send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002675 if (curpeer->flags & PEER_F_HEARTBEAT) {
2676 curpeer->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002677 repl = peer_send_heartbeatmsg(appctx, curpeer, curpeers);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002678 if (repl <= 0) {
2679 if (repl == -1)
2680 goto out;
2681 goto switchstate;
2682 }
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002683 curpeer->tx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002684 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002685 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002686 repl = peer_send_msgs(appctx, curpeer, curpeers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002687 if (repl <= 0) {
2688 if (repl == -1)
2689 goto out;
2690 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002691 }
2692
Emeric Brun2b920a12010-09-23 18:30:22 +02002693 /* noting more to do */
2694 goto out;
2695 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002696 case PEER_SESS_ST_EXIT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002697 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002698 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002699 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002700 if (peer_send_status_errormsg(appctx) == -1)
2701 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002702 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002703 goto switchstate;
2704 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002705 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002706 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002707 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002708 if (peer_send_error_size_limitmsg(appctx) == -1)
2709 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002710 appctx->st0 = PEER_SESS_ST_END;
2711 goto switchstate;
2712 }
2713 case PEER_SESS_ST_ERRPROTO: {
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002714 TRACE_PROTO("protocol error", PEERS_EV_PROTOERR,
2715 NULL, curpeer, &prev_state);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002716 if (curpeer)
2717 curpeer->proto_err++;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002718 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002719 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002720 prev_state = appctx->st0;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002721 if (peer_send_error_protomsg(appctx) == -1) {
2722 TRACE_PROTO("could not send error message", PEERS_EV_PROTOERR);
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002723 goto out;
Frédéric Lécailleda2b0842021-01-15 16:21:28 +01002724 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002725 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002726 prev_state = appctx->st0;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002727 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002728 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002729 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002730 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002731 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002732 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002733 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002734 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002735 curpeer = NULL;
2736 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002737 si_shutw(si);
2738 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002739 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002740 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002741 }
2742 }
2743 }
2744out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002745 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002746
2747 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002748 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002749 return;
2750}
2751
Willy Tarreau30576452015-04-13 13:50:30 +02002752static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002753 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002754 .name = "<PEER>", /* used for logging */
2755 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002756 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002757};
Emeric Brun2b920a12010-09-23 18:30:22 +02002758
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002759
Emeric Brun2b920a12010-09-23 18:30:22 +02002760/*
2761 * Use this function to force a close of a peer session
2762 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002763static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002764{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002765 struct appctx *appctx = peer->appctx;
2766
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002767 /* Note that the peer sessions which have just been created
2768 * (->st0 == PEER_SESS_ST_CONNECT) must not
2769 * be shutdown, if not, the TCP session will never be closed
2770 * and stay in CLOSE_WAIT state after having been closed by
2771 * the remote side.
2772 */
2773 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002774 return;
2775
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002776 if (appctx->applet != &peer_applet)
2777 return;
2778
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002779 __peer_session_deinit(peer);
2780
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002781 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002782 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002783}
2784
Willy Tarreau91d96282015-03-13 15:47:26 +01002785/* Pre-configures a peers frontend to accept incoming connections */
2786void peers_setup_frontend(struct proxy *fe)
2787{
2788 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002789 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002790 fe->mode = PR_MODE_PEERS;
Willy Tarreau91d96282015-03-13 15:47:26 +01002791 fe->maxconn = 0;
2792 fe->conn_retries = CONN_RETRIES;
2793 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002794 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002795 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002796 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002797 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002798}
2799
Emeric Brun2b920a12010-09-23 18:30:22 +02002800/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002801 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002802 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002803static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002804{
Willy Tarreau04b92862017-09-15 11:01:04 +02002805 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002806 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002807 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002808 struct stream *s;
Emeric Brun2b920a12010-09-23 18:30:22 +02002809
Frédéric Lécaille2b0ba542021-01-18 15:14:39 +01002810 peer->new_conn++;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002811 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002812 peer->heartbeat = TICK_ETERNITY;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002813 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002814 peer->last_hdshk = now_ms;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002815 s = NULL;
2816
Emeric Brun1138fd02017-06-19 12:38:55 +02002817 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002818 if (!appctx)
2819 goto out_close;
2820
2821 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002822 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002823
Willy Tarreau04b92862017-09-15 11:01:04 +02002824 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002825 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002826 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002827 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002828 }
2829
Christopher Faulet26256f82020-09-14 11:40:13 +02002830 if ((s = stream_new(sess, &appctx->obj_type, &BUF_NULL)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002831 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002832 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002833 }
2834
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002835 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002836 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002837 appctx_wakeup(appctx);
2838
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002839 /* initiate an outgoing connection */
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002840 s->target = peer_session_target(peer, s);
Willy Tarreau9b7587a2020-10-15 07:32:10 +02002841 if (!sockaddr_alloc(&s->target_addr, &peer->addr, sizeof(peer->addr)))
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002842 goto out_free_strm;
Willy Tarreau02efeda2019-07-18 17:21:24 +02002843 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Willy Tarreaudbd02672017-12-06 17:39:53 +01002844 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002845
Emeric Brun2b920a12010-09-23 18:30:22 +02002846 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002847 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002848
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002849 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002850
Emeric Brunb3971ab2015-05-12 18:49:09 +02002851 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002852 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002853 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002854 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002855
2856 /* Error unrolling */
Willy Tarreau15b5e142015-04-04 14:38:25 +02002857 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002858 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002859 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002860 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002861 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002862 out_free_appctx:
2863 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002864 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002865 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002866}
2867
2868/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002869 * Task processing function to manage re-connect, peer session
Willy Tarreauf6c88422021-01-29 12:38:42 +01002870 * tasks wakeup on local update and heartbeat. Let's keep it exported so that it
2871 * resolves in stack traces and "show tasks".
Emeric Brun2b920a12010-09-23 18:30:22 +02002872 */
Willy Tarreauf6c88422021-01-29 12:38:42 +01002873struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002874{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002875 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002876 struct peer *ps;
2877 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002878
2879 task->expire = TICK_ETERNITY;
2880
Emeric Brunb3971ab2015-05-12 18:49:09 +02002881 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002882 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002883 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002884 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002885 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002886 return NULL;
2887 }
2888
Emeric Brun80527f52017-06-19 17:46:37 +02002889 /* Acquire lock for all peers of the section */
2890 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002891 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002892
Emeric Brun2b920a12010-09-23 18:30:22 +02002893 if (!stopping) {
2894 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002895
2896 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2897 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2898 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002899 /* Resync from local peer needed
2900 no peer was assigned for the lesson
2901 and no old local peer found
2902 or resync timeout expire */
2903
2904 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002905 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002906
2907 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002908 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002909 }
2910
2911 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002912 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002913 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002914 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002915 if (!ps->appctx) {
2916 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002917 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002918 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002919 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002920 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002921 tick_is_expired(ps->reconnect, now_ms))) {
2922 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002923 * or previous peer connection established with success
2924 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002925 * and reconnection timer is expired */
2926
2927 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002928 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002929 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002930 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002931 /* If previous session failed during connection
2932 * but reconnection timer is not expired */
2933
2934 /* reschedule task for reconnect */
2935 task->expire = tick_first(task->expire, ps->reconnect);
2936 }
2937 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002938 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002939 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002940 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002941 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2942 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002943 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2944 /* Resync from a remote is needed
2945 * and no peer was assigned for lesson
2946 * and current peer may be up2date */
2947
2948 /* assign peer for the lesson */
2949 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002950 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002951
Willy Tarreau9df94c22016-10-31 18:42:52 +01002952 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002953 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002954 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002955 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002956 int update_to_push = 0;
2957
Emeric Brunb3971ab2015-05-12 18:49:09 +02002958 /* Awake session if there is data to push */
2959 for (st = ps->tables; st ; st = st->next) {
2960 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002961 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002962 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002963 /* There is no need to send a heartbeat message
2964 * when some updates must be pushed. The remote
2965 * peer will consider <ps> peer as alive when it will
2966 * receive these updates.
2967 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002968 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002969 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002970 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002971 /* We are going to send updates, let's ensure we will
2972 * come back to send heartbeat messages or to reconnect.
2973 */
2974 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002975 appctx_wakeup(ps->appctx);
2976 break;
2977 }
2978 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002979 /* When there are updates to send we do not reconnect
2980 * and do not send heartbeat message either.
2981 */
2982 if (!update_to_push) {
2983 if (tick_is_expired(ps->reconnect, now_ms)) {
2984 if (ps->flags & PEER_F_ALIVE) {
2985 /* This peer was alive during a 'reconnect' period.
2986 * Flag it as not alive again for the next period.
2987 */
2988 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002989 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002990 }
2991 else {
Willy Tarreau52bf8392020-03-08 00:42:37 +01002992 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002993 ps->heartbeat = TICK_ETERNITY;
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002994 peer_session_forceshutdown(ps);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002995 ps->no_hbt++;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002996 }
2997 }
2998 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2999 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
3000 ps->flags |= PEER_F_HEARTBEAT;
3001 appctx_wakeup(ps->appctx);
3002 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01003003 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01003004 }
Emeric Brun2b920a12010-09-23 18:30:22 +02003005 }
3006 /* else do nothing */
3007 } /* SUCCESSCODE */
3008 } /* !ps->peer->local */
3009 } /* for */
3010
3011 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003012 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
3013 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
3014 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003015 /* Resync from remote peer needed
3016 * no peer was assigned for the lesson
3017 * and resync timeout expire */
3018
3019 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003020 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02003021 }
3022
Emeric Brunb3971ab2015-05-12 18:49:09 +02003023 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003024 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02003025 /* reschedule task to resync timeout if not expired, to ended resync if needed */
3026 if (!tick_is_expired(peers->resync_timeout, now_ms))
3027 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02003028 }
3029 } /* !stopping */
3030 else {
3031 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01003032 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08003033 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003034 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003035 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01003036 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003037 peers->flags |= PEERS_F_DONOTSTOP;
3038 ps = peers->local;
3039 for (st = ps->tables; st ; st = st->next)
3040 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02003041 }
3042
3043 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003044 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02003045 /* we're killing a connection, we must apply a random delay before
3046 * retrying otherwise the other end will do the same and we can loop
3047 * for a while.
3048 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01003049 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01003050 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02003051 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02003052 }
3053 }
3054 }
Emeric Brun2b920a12010-09-23 18:30:22 +02003055
Emeric Brunb3971ab2015-05-12 18:49:09 +02003056 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02003057 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02003058 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003059 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01003060 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003061 peers->flags &= ~PEERS_F_DONOTSTOP;
3062 for (st = ps->tables; st ; st = st->next)
3063 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02003064 }
3065 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01003066 else if (!ps->appctx) {
3067 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02003068 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01003069 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
3070 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
3071 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003072 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01003073 * or previous peer connection was successfully established
3074 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02003075 * or during previous connect, peer replies a try again statuscode */
3076
3077 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003078 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02003079 }
3080 else {
3081 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003082 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003083 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01003084 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003085 peers->flags &= ~PEERS_F_DONOTSTOP;
3086 for (st = ps->tables; st ; st = st->next)
3087 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02003088 }
3089 }
3090 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02003091 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01003092 /* current peer connection is active and established
3093 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02003094 for (st = ps->tables; st ; st = st->next) {
3095 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02003096 appctx_wakeup(ps->appctx);
3097 break;
3098 }
3099 }
Emeric Brun2b920a12010-09-23 18:30:22 +02003100 }
3101 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02003102
3103 /* Release lock for all peers of the section */
3104 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003105 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02003106
Emeric Brun2b920a12010-09-23 18:30:22 +02003107 /* Wakeup for re-connect */
3108 return task;
3109}
3110
Emeric Brunb3971ab2015-05-12 18:49:09 +02003111
Emeric Brun2b920a12010-09-23 18:30:22 +02003112/*
Willy Tarreaud9443442018-10-15 11:18:03 +02003113 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02003114 */
Willy Tarreaud9443442018-10-15 11:18:03 +02003115int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02003116{
Emeric Brun2b920a12010-09-23 18:30:22 +02003117 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02003118
Emeric Brun2b920a12010-09-23 18:30:22 +02003119 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02003120 peers->peers_fe->maxconn += 3;
3121 }
3122
Emeric Brunc60def82017-09-27 14:59:38 +02003123 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02003124 if (!peers->sync_task)
3125 return 0;
3126
Emeric Brunb3971ab2015-05-12 18:49:09 +02003127 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02003128 peers->sync_task->context = (void *)peers;
3129 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
3130 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02003131 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02003132}
3133
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003134/*
3135 * Allocate a cache a dictionary entries used upon transmission.
3136 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003137static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003138{
3139 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003140 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003141
3142 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003143 entries = calloc(max_entries, sizeof *entries);
3144 if (!d || !entries)
3145 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003146
3147 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02003148 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003149 d->cached_entries = EB_ROOT_UNIQUE;
3150 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003151
3152 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003153
3154 err:
3155 free(d);
3156 free(entries);
3157 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003158}
3159
3160/*
3161 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
3162 * as maximum of entries.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05003163 * Return the dictionary cache if succeeded, NULL if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003164 * Must be deallocated calling free_dcache().
3165 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003166static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003167{
3168 struct dcache_tx *dc_tx;
3169 struct dcache *dc;
3170 struct dcache_rx *dc_rx;
3171
3172 dc = calloc(1, sizeof *dc);
3173 dc_tx = new_dcache_tx(max_entries);
3174 dc_rx = calloc(max_entries, sizeof *dc_rx);
3175 if (!dc || !dc_tx || !dc_rx)
3176 goto err;
3177
3178 dc->tx = dc_tx;
3179 dc->rx = dc_rx;
3180 dc->max_entries = max_entries;
3181
3182 return dc;
3183
3184 err:
3185 free(dc);
3186 free(dc_tx);
3187 free(dc_rx);
3188 return NULL;
3189}
3190
3191/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003192 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
3193 * entries used upon transmission.
3194 * Return the entry if found, NULL if not.
3195 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003196static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
3197 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003198{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003199 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003200}
3201
3202/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003203 * Flush <dc> cache.
3204 * Always succeeds.
3205 */
3206static inline void flush_dcache(struct peer *peer)
3207{
3208 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003209 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003210
Frédéric Lécailleea875e62020-11-12 21:01:54 +01003211 for (i = 0; i < dc->max_entries; i++) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003212 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécailleea875e62020-11-12 21:01:54 +01003213 dc->tx->entries[i].key = NULL;
Thayne McCombs92149f92020-11-20 01:28:26 -07003214 dict_entry_unref(&server_key_dict, dc->rx[i].de);
3215 dc->rx[i].de = NULL;
Frédéric Lécailleea875e62020-11-12 21:01:54 +01003216 }
3217 dc->tx->prev_lookup = NULL;
3218 dc->tx->lru_key = 0;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003219
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003220 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003221}
3222
3223/*
3224 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
3225 * with information provided by <i> dictionary cache entry (especially the value
3226 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003227 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003228 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003229static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003230{
3231 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003232 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003233
3234 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02003235
3236 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
3237 o = dc_tx->prev_lookup;
3238 } else {
3239 o = dcache_tx_lookup_value(dc_tx, i);
3240 if (o) {
3241 /* Save it */
3242 dc_tx->prev_lookup = o;
3243 }
3244 }
3245
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003246 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003247 /* Copy the ID. */
3248 i->id = o - dc->tx->entries;
3249 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003250 }
3251
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003252 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02003253 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003254
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003255 ebpt_delete(o);
3256 o->key = i->entry.key;
3257 ebpt_insert(&dc_tx->cached_entries, o);
3258 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003259
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003260 /* Update the index for the next entry to put in cache */
3261 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003262
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003263 return o;
3264}
Emeric Brunb3971ab2015-05-12 18:49:09 +02003265
3266/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003267 * Allocate a dictionary cache for each peer of <peers> section.
3268 * Return 1 if succeeded, 0 if not.
3269 */
3270int peers_alloc_dcache(struct peers *peers)
3271{
3272 struct peer *p;
3273
3274 for (p = peers->remote; p; p = p->next) {
3275 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
3276 if (!p->dcache)
3277 return 0;
3278 }
3279
3280 return 1;
3281}
3282
3283/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02003284 * Function used to register a table for sync on a group of peers
3285 *
3286 */
3287void peers_register_table(struct peers *peers, struct stktable *table)
3288{
3289 struct shared_table *st;
3290 struct peer * curpeer;
3291 int id = 0;
3292
3293 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003294 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003295 st->table = table;
3296 st->next = curpeer->tables;
3297 if (curpeer->tables)
3298 id = curpeer->tables->local_id;
3299 st->local_id = id + 1;
3300
3301 curpeer->tables = st;
3302 }
3303
3304 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003305}
3306
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003307/*
3308 * Parse the "show peers" command arguments.
3309 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3310 * error message.
3311 */
3312static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3313{
3314 appctx->ctx.cfgpeers.target = NULL;
3315
3316 if (*args[2]) {
3317 struct peers *p;
3318
3319 for (p = cfg_peers; p; p = p->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003320 if (strcmp(p->id, args[2]) == 0) {
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003321 appctx->ctx.cfgpeers.target = p;
3322 break;
3323 }
3324 }
3325
Willy Tarreau9d008692019-08-09 11:21:01 +02003326 if (!p)
3327 return cli_err(appctx, "No such peers\n");
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003328 }
3329
3330 return 0;
3331}
3332
3333/*
3334 * This function dumps the peer state information of <peers> "peers" section.
3335 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3336 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3337 */
3338static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3339{
3340 struct tm tm;
3341
3342 get_localtime(peers->last_change, &tm);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003343 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 +02003344 peers,
3345 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3346 tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003347 peers->id, peers->disabled, peers->flags,
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003348 peers->resync_timeout ?
3349 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3350 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003351 TICKS_TO_MS(1000)) : "<NEVER>",
3352 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003353
3354 if (ci_putchk(si_ic(si), msg) == -1) {
3355 si_rx_room_blk(si);
3356 return 0;
3357 }
3358
3359 return 1;
3360}
3361
3362/*
3363 * This function dumps <peer> state information.
3364 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3365 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3366 */
3367static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3368{
3369 struct connection *conn;
3370 char pn[INET6_ADDRSTRLEN];
3371 struct stream_interface *peer_si;
3372 struct stream *peer_s;
3373 struct appctx *appctx;
3374 struct shared_table *st;
3375
3376 addr_to_str(&peer->addr, pn, sizeof pn);
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003377 chunk_appendf(msg, " %p: id=%s(%s,%s) addr=%s:%d last_status=%s",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003378 peer, peer->id,
3379 peer->local ? "local" : "remote",
Frédéric Lécaillee7e2b212020-10-05 12:33:07 +02003380 peer->appctx ? "active" : "inactive",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003381 pn, get_host_port(&peer->addr),
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003382 statuscode_str(peer->statuscode));
3383
3384 chunk_appendf(msg, " last_hdshk=%s\n",
3385 peer->last_hdshk ? human_time(TICKS_TO_MS(now_ms - peer->last_hdshk),
3386 TICKS_TO_MS(1000)) : "<NEVER>");
3387
3388 chunk_appendf(msg, " reconnect=%s",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003389 peer->reconnect ?
3390 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3391 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003392 TICKS_TO_MS(1000)) : "<NEVER>");
3393
3394 chunk_appendf(msg, " heartbeat=%s",
3395 peer->heartbeat ?
3396 tick_is_expired(peer->heartbeat, now_ms) ? "<PAST>" :
3397 human_time(TICKS_TO_MS(peer->heartbeat - now_ms),
3398 TICKS_TO_MS(1000)) : "<NEVER>");
3399
3400 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 +01003401 peer->confirm, peer->tx_hbt, peer->rx_hbt,
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003402 peer->no_hbt, peer->new_conn, peer->proto_err, peer->coll);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003403
3404 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3405
3406 appctx = peer->appctx;
3407 if (!appctx)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003408 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003409
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003410 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3411 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003412
3413 peer_si = peer->appctx->owner;
3414 if (!peer_si)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003415 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003416
3417 peer_s = si_strm(peer_si);
3418 if (!peer_s)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003419 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003420
3421 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3422
3423 conn = objt_conn(strm_orig(peer_s));
3424 if (conn)
3425 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3426
Willy Tarreau3ca14902019-07-17 14:53:15 +02003427 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 +02003428 case AF_INET:
3429 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003430 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(conn->src));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003431 break;
3432 case AF_UNIX:
3433 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3434 break;
3435 }
3436
Willy Tarreau3ca14902019-07-17 14:53:15 +02003437 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 +02003438 case AF_INET:
3439 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003440 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(conn->dst));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003441 break;
3442 case AF_UNIX:
3443 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3444 break;
3445 }
3446
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003447 table_info:
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003448 if (peer->remote_table)
3449 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3450 peer->remote_table,
3451 peer->remote_table->table->id,
3452 peer->remote_table->local_id,
3453 peer->remote_table->remote_id);
3454
3455 if (peer->last_local_table)
3456 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3457 peer->last_local_table,
3458 peer->last_local_table->table->id,
3459 peer->last_local_table->local_id,
3460 peer->last_local_table->remote_id);
3461
3462 if (peer->tables) {
3463 chunk_appendf(&trash, "\n shared tables:");
3464 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003465 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003466 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003467 struct dcache *dcache;
3468
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003469 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003470 dcache = peer->dcache;
3471
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003472 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3473 "flags=0x%x remote_data=0x%llx",
3474 st, st->local_id, st->remote_id,
3475 st->flags, (unsigned long long)st->remote_data);
3476 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3477 " teaching_origin=%u update=%u",
3478 st->last_acked, st->last_pushed, st->last_get,
3479 st->teaching_origin, st->update);
3480 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3481 " commitupdate=%u syncing=%u",
3482 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003483 chunk_appendf(&trash, "\n TX dictionary cache:");
3484 count = 0;
3485 for (i = 0; i < dcache->max_entries; i++) {
3486 struct ebpt_node *node;
3487 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003488
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003489 node = &dcache->tx->entries[i];
3490 if (!node->key)
3491 break;
3492
3493 if (!count++)
3494 chunk_appendf(&trash, "\n ");
3495 de = node->key;
3496 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3497 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003498 }
3499 chunk_appendf(&trash, "\n RX dictionary cache:");
3500 count = 0;
3501 for (i = 0; i < dcache->max_entries; i++) {
3502 if (!count++)
3503 chunk_appendf(&trash, "\n ");
3504 chunk_appendf(&trash, " %3u -> %s", i,
3505 dcache->rx[i].de ?
3506 (char *)dcache->rx[i].de->value.key : "-");
3507 count &= 0x3;
3508 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003509 }
3510 }
3511
3512 end:
3513 chunk_appendf(&trash, "\n");
3514 if (ci_putchk(si_ic(si), msg) == -1) {
3515 si_rx_room_blk(si);
3516 return 0;
3517 }
3518
3519 return 1;
3520}
3521
3522/*
3523 * This function dumps all the peers of "peers" section.
3524 * Returns 0 if the output buffer is full and needs to be called
3525 * again, non-zero if not. It proceeds in an isolated thread, so
3526 * there is no thread safety issue here.
3527 */
3528static int cli_io_handler_show_peers(struct appctx *appctx)
3529{
3530 int show_all;
3531 int ret = 0, first_peers = 1;
3532 struct stream_interface *si = appctx->owner;
3533
3534 thread_isolate();
3535
3536 show_all = !appctx->ctx.cfgpeers.target;
3537
3538 chunk_reset(&trash);
3539
3540 while (appctx->st2 != STAT_ST_FIN) {
3541 switch (appctx->st2) {
3542 case STAT_ST_INIT:
3543 if (show_all)
3544 appctx->ctx.cfgpeers.peers = cfg_peers;
3545 else
3546 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3547
3548 appctx->st2 = STAT_ST_LIST;
3549 /* fall through */
3550
3551 case STAT_ST_LIST:
3552 if (!appctx->ctx.cfgpeers.peers) {
3553 /* No more peers list. */
3554 appctx->st2 = STAT_ST_END;
3555 }
3556 else {
3557 if (!first_peers)
3558 chunk_appendf(&trash, "\n");
3559 else
3560 first_peers = 0;
3561 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3562 goto out;
3563
3564 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3565 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3566 appctx->st2 = STAT_ST_INFO;
3567 }
3568 break;
3569
3570 case STAT_ST_INFO:
3571 if (!appctx->ctx.cfgpeers.peer) {
3572 /* End of peer list */
3573 if (show_all)
3574 appctx->st2 = STAT_ST_LIST;
3575 else
3576 appctx->st2 = STAT_ST_END;
3577 }
3578 else {
3579 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3580 goto out;
3581
3582 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3583 }
3584 break;
3585
3586 case STAT_ST_END:
3587 appctx->st2 = STAT_ST_FIN;
3588 break;
3589 }
3590 }
3591 ret = 1;
3592 out:
3593 thread_release();
3594 return ret;
3595}
3596
3597/*
3598 * CLI keywords.
3599 */
3600static struct cli_kw_list cli_kws = {{ }, {
3601 { { "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, },
3602 {},
3603}};
3604
3605/* Register cli keywords */
3606INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3607