blob: d76a1f87650e054b858deddb54bcb568b3315eb4 [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>
Emeric Brun2b920a12010-09-23 18:30:22 +020045
Emeric Brun2b920a12010-09-23 18:30:22 +020046
47/*******************************/
48/* Current peer learning state */
49/*******************************/
50
51/******************************/
Emeric Brunb3971ab2015-05-12 18:49:09 +020052/* Current peers section resync state */
Emeric Brun2b920a12010-09-23 18:30:22 +020053/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010054#define PEERS_F_RESYNC_LOCAL 0x00000001 /* Learn from local finished or no more needed */
55#define PEERS_F_RESYNC_REMOTE 0x00000002 /* Learn from remote finished or no more needed */
56#define PEERS_F_RESYNC_ASSIGN 0x00000004 /* A peer was assigned to learn our lesson */
57#define PEERS_F_RESYNC_PROCESS 0x00000008 /* The assigned peer was requested for resync */
58#define PEERS_F_DONOTSTOP 0x00010000 /* Main table sync task block process during soft stop
59 to push data to new process */
Emeric Brun2b920a12010-09-23 18:30:22 +020060
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010061#define PEERS_RESYNC_STATEMASK (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
62#define PEERS_RESYNC_FROMLOCAL 0x00000000
63#define PEERS_RESYNC_FROMREMOTE PEERS_F_RESYNC_LOCAL
64#define PEERS_RESYNC_FINISHED (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
Emeric Brunb3971ab2015-05-12 18:49:09 +020065
66/***********************************/
67/* Current shared table sync state */
68/***********************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010069#define SHTABLE_F_TEACH_STAGE1 0x00000001 /* Teach state 1 complete */
70#define SHTABLE_F_TEACH_STAGE2 0x00000002 /* Teach state 2 complete */
Emeric Brun2b920a12010-09-23 18:30:22 +020071
72/******************************/
73/* Remote peer teaching state */
74/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010075#define PEER_F_TEACH_PROCESS 0x00000001 /* Teach a lesson to current peer */
76#define PEER_F_TEACH_FINISHED 0x00000008 /* Teach conclude, (wait for confirm) */
77#define PEER_F_TEACH_COMPLETE 0x00000010 /* All that we know already taught to current peer, used only for a local peer */
78#define PEER_F_LEARN_ASSIGN 0x00000100 /* Current peer was assigned for a lesson */
79#define PEER_F_LEARN_NOTUP2DATE 0x00000200 /* Learn from peer finished but peer is not up to date */
80#define PEER_F_ALIVE 0x20000000 /* Used to flag a peer a alive. */
81#define PEER_F_HEARTBEAT 0x40000000 /* Heartbeat message to send. */
82#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 +020083
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010084#define PEER_TEACH_RESET ~(PEER_F_TEACH_PROCESS|PEER_F_TEACH_FINISHED) /* PEER_F_TEACH_COMPLETE should never be reset */
85#define PEER_LEARN_RESET ~(PEER_F_LEARN_ASSIGN|PEER_F_LEARN_NOTUP2DATE)
Emeric Brun2b920a12010-09-23 18:30:22 +020086
Frédéric Lécaille54bff832019-03-26 10:25:20 +010087#define PEER_RESYNC_TIMEOUT 5000 /* 5 seconds */
88#define PEER_RECONNECT_TIMEOUT 5000 /* 5 seconds */
Frédéric Lécaille645635d2019-02-11 17:49:39 +010089#define PEER_HEARTBEAT_TIMEOUT 3000 /* 3 seconds */
90
Emeric Brunb3971ab2015-05-12 18:49:09 +020091/*****************************/
92/* Sync message class */
93/*****************************/
94enum {
95 PEER_MSG_CLASS_CONTROL = 0,
96 PEER_MSG_CLASS_ERROR,
97 PEER_MSG_CLASS_STICKTABLE = 10,
98 PEER_MSG_CLASS_RESERVED = 255,
99};
100
101/*****************************/
102/* control message types */
103/*****************************/
104enum {
105 PEER_MSG_CTRL_RESYNCREQ = 0,
106 PEER_MSG_CTRL_RESYNCFINISHED,
107 PEER_MSG_CTRL_RESYNCPARTIAL,
108 PEER_MSG_CTRL_RESYNCCONFIRM,
Frédéric Lécaille645635d2019-02-11 17:49:39 +0100109 PEER_MSG_CTRL_HEARTBEAT,
Emeric Brunb3971ab2015-05-12 18:49:09 +0200110};
111
112/*****************************/
113/* error message types */
114/*****************************/
115enum {
116 PEER_MSG_ERR_PROTOCOL = 0,
117 PEER_MSG_ERR_SIZELIMIT,
118};
119
Emeric Brun530ba382020-06-02 11:17:42 +0200120/* network key types;
121 * network types were directly and mistakenly
122 * mapped on sample types, to keep backward
123 * compatiblitiy we keep those values but
124 * we now use a internal/network mapping
125 * to avoid further mistakes adding or
126 * modifying internals types
127 */
128enum {
129 PEER_KT_ANY = 0, /* any type */
130 PEER_KT_RESV1, /* UNUSED */
131 PEER_KT_SINT, /* signed 64bits integer type */
132 PEER_KT_RESV3, /* UNUSED */
133 PEER_KT_IPV4, /* ipv4 type */
134 PEER_KT_IPV6, /* ipv6 type */
135 PEER_KT_STR, /* char string type */
136 PEER_KT_BIN, /* buffer type */
137 PEER_KT_TYPES /* number of types, must always be last */
138};
139
140/* Map used to retrieve network type from internal type
141 * Note: Undeclared mapping maps entry to PEER_KT_ANY == 0
142 */
143static int peer_net_key_type[SMP_TYPES] = {
144 [SMP_T_SINT] = PEER_KT_SINT,
145 [SMP_T_IPV4] = PEER_KT_IPV4,
146 [SMP_T_IPV6] = PEER_KT_IPV6,
147 [SMP_T_STR] = PEER_KT_STR,
148 [SMP_T_BIN] = PEER_KT_BIN,
149};
150
151/* Map used to retrieve internal type from external type
152 * Note: Undeclared mapping maps entry to SMP_T_ANY == 0
153 */
154static int peer_int_key_type[PEER_KT_TYPES] = {
155 [PEER_KT_SINT] = SMP_T_SINT,
156 [PEER_KT_IPV4] = SMP_T_IPV4,
157 [PEER_KT_IPV6] = SMP_T_IPV6,
158 [PEER_KT_STR] = SMP_T_STR,
159 [PEER_KT_BIN] = SMP_T_BIN,
160};
161
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100162/*
163 * Parameters used by functions to build peer protocol messages. */
164struct peer_prep_params {
165 struct {
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100166 struct peer *peer;
167 } hello;
168 struct {
169 unsigned int st1;
170 } error_status;
171 struct {
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100172 struct stksess *stksess;
173 struct shared_table *shared_table;
174 unsigned int updateid;
175 int use_identifier;
176 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200177 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100178 } updt;
179 struct {
180 struct shared_table *shared_table;
181 } swtch;
182 struct {
183 struct shared_table *shared_table;
184 } ack;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100185 struct {
186 unsigned char head[2];
187 } control;
188 struct {
189 unsigned char head[2];
190 } error;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100191};
Emeric Brunb3971ab2015-05-12 18:49:09 +0200192
193/*******************************/
194/* stick table sync mesg types */
195/* Note: ids >= 128 contains */
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500196/* id message contains data */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200197/*******************************/
Olivier Houchard33992262018-10-16 18:49:26 +0200198#define PEER_MSG_STKT_UPDATE 0x80
199#define PEER_MSG_STKT_INCUPDATE 0x81
200#define PEER_MSG_STKT_DEFINE 0x82
201#define PEER_MSG_STKT_SWITCH 0x83
202#define PEER_MSG_STKT_ACK 0x84
203#define PEER_MSG_STKT_UPDATE_TIMED 0x85
204#define PEER_MSG_STKT_INCUPDATE_TIMED 0x86
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +0200205/* All the stick-table message identifiers abova have the #7 bit set */
206#define PEER_MSG_STKT_BIT 7
207#define PEER_MSG_STKT_BIT_MASK (1 << PEER_MSG_STKT_BIT)
Emeric Brun2b920a12010-09-23 18:30:22 +0200208
Frédéric Lécaille39143342019-05-24 14:32:27 +0200209/* The maximum length of an encoded data length. */
210#define PEER_MSG_ENC_LENGTH_MAXLEN 5
211
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200212/* Minimum 64-bits value encoded with 2 bytes */
213#define PEER_ENC_2BYTES_MIN 0xf0 /* 0xf0 (or 240) */
214/* 3 bytes */
215#define PEER_ENC_3BYTES_MIN ((1ULL << 11) | PEER_ENC_2BYTES_MIN) /* 0x8f0 (or 2288) */
216/* 4 bytes */
217#define PEER_ENC_4BYTES_MIN ((1ULL << 18) | PEER_ENC_3BYTES_MIN) /* 0x408f0 (or 264432) */
218/* 5 bytes */
219#define PEER_ENC_5BYTES_MIN ((1ULL << 25) | PEER_ENC_4BYTES_MIN) /* 0x20408f0 (or 33818864) */
220/* 6 bytes */
221#define PEER_ENC_6BYTES_MIN ((1ULL << 32) | PEER_ENC_5BYTES_MIN) /* 0x1020408f0 (or 4328786160) */
222/* 7 bytes */
223#define PEER_ENC_7BYTES_MIN ((1ULL << 39) | PEER_ENC_6BYTES_MIN) /* 0x81020408f0 (or 554084600048) */
224/* 8 bytes */
225#define PEER_ENC_8BYTES_MIN ((1ULL << 46) | PEER_ENC_7BYTES_MIN) /* 0x4081020408f0 (or 70922828777712) */
226/* 9 bytes */
227#define PEER_ENC_9BYTES_MIN ((1ULL << 53) | PEER_ENC_8BYTES_MIN) /* 0x204081020408f0 (or 9078122083518704) */
228/* 10 bytes */
229#define PEER_ENC_10BYTES_MIN ((1ULL << 60) | PEER_ENC_9BYTES_MIN) /* 0x10204081020408f0 (or 1161999626690365680) */
230
231/* #7 bit used to detect the last byte to be encoded */
232#define PEER_ENC_STOP_BIT 7
233/* The byte minimum value with #7 bit set */
234#define PEER_ENC_STOP_BYTE (1 << PEER_ENC_STOP_BIT)
235/* The left most number of bits set for PEER_ENC_2BYTES_MIN */
236#define PEER_ENC_2BYTES_MIN_BITS 4
237
Frédéric Lécaille39143342019-05-24 14:32:27 +0200238#define PEER_MSG_HEADER_LEN 2
239
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200240#define PEER_STKT_CACHE_MAX_ENTRIES 128
241
Emeric Brun2b920a12010-09-23 18:30:22 +0200242/**********************************/
243/* Peer Session IO handler states */
244/**********************************/
245
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100246enum {
247 PEER_SESS_ST_ACCEPT = 0, /* Initial state for session create by an accept, must be zero! */
248 PEER_SESS_ST_GETVERSION, /* Validate supported protocol version */
249 PEER_SESS_ST_GETHOST, /* Validate host ID correspond to local host id */
250 PEER_SESS_ST_GETPEER, /* Validate peer ID correspond to a known remote peer id */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100251 /* after this point, data were possibly exchanged */
252 PEER_SESS_ST_SENDSUCCESS, /* Send ret code 200 (success) and wait for message */
253 PEER_SESS_ST_CONNECT, /* Initial state for session create on a connect, push presentation into buffer */
254 PEER_SESS_ST_GETSTATUS, /* Wait for the welcome message */
255 PEER_SESS_ST_WAITMSG, /* Wait for data messages */
256 PEER_SESS_ST_EXIT, /* Exit with status code */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200257 PEER_SESS_ST_ERRPROTO, /* Send error proto message before exit */
258 PEER_SESS_ST_ERRSIZE, /* Send error size message before exit */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100259 PEER_SESS_ST_END, /* Killed session */
260};
Emeric Brun2b920a12010-09-23 18:30:22 +0200261
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100262/***************************************************/
263/* Peer Session status code - part of the protocol */
264/***************************************************/
Emeric Brun2b920a12010-09-23 18:30:22 +0200265
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100266#define PEER_SESS_SC_CONNECTCODE 100 /* connect in progress */
267#define PEER_SESS_SC_CONNECTEDCODE 110 /* tcp connect success */
Emeric Brun2b920a12010-09-23 18:30:22 +0200268
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100269#define PEER_SESS_SC_SUCCESSCODE 200 /* accept or connect successful */
Emeric Brun2b920a12010-09-23 18:30:22 +0200270
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100271#define PEER_SESS_SC_TRYAGAIN 300 /* try again later */
Emeric Brun2b920a12010-09-23 18:30:22 +0200272
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100273#define PEER_SESS_SC_ERRPROTO 501 /* error protocol */
274#define PEER_SESS_SC_ERRVERSION 502 /* unknown protocol version */
275#define PEER_SESS_SC_ERRHOST 503 /* bad host name */
276#define PEER_SESS_SC_ERRPEER 504 /* unknown peer */
Emeric Brun2b920a12010-09-23 18:30:22 +0200277
278#define PEER_SESSION_PROTO_NAME "HAProxyS"
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200279#define PEER_MAJOR_VER 2
280#define PEER_MINOR_VER 1
281#define PEER_DWNGRD_MINOR_VER 0
Emeric Brun2b920a12010-09-23 18:30:22 +0200282
Willy Tarreau6254a922019-01-29 17:45:23 +0100283static size_t proto_len = sizeof(PEER_SESSION_PROTO_NAME) - 1;
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200284struct peers *cfg_peers = NULL;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200285static void peer_session_forceshutdown(struct peer *peer);
Emeric Brun2b920a12010-09-23 18:30:22 +0200286
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200287static struct ebpt_node *dcache_tx_insert(struct dcache *dc,
288 struct dcache_tx_entry *i);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200289static inline void flush_dcache(struct peer *peer);
290
Frédéric Lécaille95679dc2019-04-15 10:25:27 +0200291static const char *statuscode_str(int statuscode)
292{
293 switch (statuscode) {
294 case PEER_SESS_SC_CONNECTCODE:
295 return "CONN";
296 case PEER_SESS_SC_CONNECTEDCODE:
297 return "HSHK";
298 case PEER_SESS_SC_SUCCESSCODE:
299 return "ESTA";
300 case PEER_SESS_SC_TRYAGAIN:
301 return "RETR";
302 case PEER_SESS_SC_ERRPROTO:
303 return "PROT";
304 case PEER_SESS_SC_ERRVERSION:
305 return "VERS";
306 case PEER_SESS_SC_ERRHOST:
307 return "NAME";
308 case PEER_SESS_SC_ERRPEER:
309 return "UNKN";
310 default:
311 return "NONE";
312 }
313}
314
Emeric Brun18928af2017-03-29 16:32:53 +0200315/* This function encode an uint64 to 'dynamic' length format.
316 The encoded value is written at address *str, and the
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500317 caller must assure that size after *str is large enough.
Emeric Brun18928af2017-03-29 16:32:53 +0200318 At return, the *str is set at the next Byte after then
319 encoded integer. The function returns then length of the
320 encoded integer in Bytes */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200321int intencode(uint64_t i, char **str) {
322 int idx = 0;
323 unsigned char *msg;
324
Emeric Brunb3971ab2015-05-12 18:49:09 +0200325 msg = (unsigned char *)*str;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200326 if (i < PEER_ENC_2BYTES_MIN) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200327 msg[0] = (unsigned char)i;
328 *str = (char *)&msg[idx+1];
329 return (idx+1);
330 }
331
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200332 msg[idx] =(unsigned char)i | PEER_ENC_2BYTES_MIN;
333 i = (i - PEER_ENC_2BYTES_MIN) >> PEER_ENC_2BYTES_MIN_BITS;
334 while (i >= PEER_ENC_STOP_BYTE) {
335 msg[++idx] = (unsigned char)i | PEER_ENC_STOP_BYTE;
336 i = (i - PEER_ENC_STOP_BYTE) >> PEER_ENC_STOP_BIT;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200337 }
338 msg[++idx] = (unsigned char)i;
339 *str = (char *)&msg[idx+1];
340 return (idx+1);
341}
342
343
344/* This function returns the decoded integer or 0
345 if decode failed
346 *str point on the beginning of the integer to decode
347 at the end of decoding *str point on the end of the
348 encoded integer or to null if end is reached */
Emeric Brun18928af2017-03-29 16:32:53 +0200349uint64_t intdecode(char **str, char *end)
350{
Emeric Brunb3971ab2015-05-12 18:49:09 +0200351 unsigned char *msg;
Emeric Brun18928af2017-03-29 16:32:53 +0200352 uint64_t i;
353 int shift;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200354
355 if (!*str)
356 return 0;
357
358 msg = (unsigned char *)*str;
Emeric Brun18928af2017-03-29 16:32:53 +0200359 if (msg >= (unsigned char *)end)
360 goto fail;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200361
Emeric Brun18928af2017-03-29 16:32:53 +0200362 i = *(msg++);
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200363 if (i >= PEER_ENC_2BYTES_MIN) {
364 shift = PEER_ENC_2BYTES_MIN_BITS;
Emeric Brun18928af2017-03-29 16:32:53 +0200365 do {
366 if (msg >= (unsigned char *)end)
367 goto fail;
368 i += (uint64_t)*msg << shift;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200369 shift += PEER_ENC_STOP_BIT;
370 } while (*(msg++) >= PEER_ENC_STOP_BYTE);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200371 }
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100372 *str = (char *)msg;
373 return i;
Emeric Brun18928af2017-03-29 16:32:53 +0200374
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100375 fail:
376 *str = NULL;
377 return 0;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200378}
Emeric Brun2b920a12010-09-23 18:30:22 +0200379
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100380/*
381 * Build a "hello" peer protocol message.
382 * Return the number of written bytes written to build this messages if succeeded,
383 * 0 if not.
384 */
385static int peer_prepare_hellomsg(char *msg, size_t size, struct peer_prep_params *p)
386{
387 int min_ver, ret;
388 struct peer *peer;
389
390 peer = p->hello.peer;
391 min_ver = (peer->flags & PEER_F_DWNGRD) ? PEER_DWNGRD_MINOR_VER : PEER_MINOR_VER;
392 /* Prepare headers */
393 ret = snprintf(msg, size, PEER_SESSION_PROTO_NAME " %u.%u\n%s\n%s %d %d\n",
394 PEER_MAJOR_VER, min_ver, peer->id, localpeer, (int)getpid(), relative_pid);
395 if (ret >= size)
396 return 0;
397
398 return ret;
399}
400
401/*
402 * Build a "handshake succeeded" status message.
403 * Return the number of written bytes written to build this messages if succeeded,
404 * 0 if not.
405 */
406static int peer_prepare_status_successmsg(char *msg, size_t size, struct peer_prep_params *p)
407{
408 int ret;
409
410 ret = snprintf(msg, size, "%d\n", PEER_SESS_SC_SUCCESSCODE);
411 if (ret >= size)
412 return 0;
413
414 return ret;
415}
416
417/*
418 * Build an error status message.
419 * Return the number of written bytes written to build this messages if succeeded,
420 * 0 if not.
421 */
422static int peer_prepare_status_errormsg(char *msg, size_t size, struct peer_prep_params *p)
423{
424 int ret;
425 unsigned int st1;
426
427 st1 = p->error_status.st1;
428 ret = snprintf(msg, size, "%d\n", st1);
429 if (ret >= size)
430 return 0;
431
432 return ret;
433}
434
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200435/* Set the stick-table UPDATE message type byte at <msg_type> address,
436 * depending on <use_identifier> and <use_timed> boolean parameters.
437 * Always successful.
438 */
439static inline void peer_set_update_msg_type(char *msg_type, int use_identifier, int use_timed)
440{
441 if (use_timed) {
442 if (use_identifier)
443 *msg_type = PEER_MSG_STKT_UPDATE_TIMED;
444 else
445 *msg_type = PEER_MSG_STKT_INCUPDATE_TIMED;
446 }
447 else {
448 if (use_identifier)
449 *msg_type = PEER_MSG_STKT_UPDATE;
450 else
451 *msg_type = PEER_MSG_STKT_INCUPDATE;
452 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200453}
Emeric Brun2b920a12010-09-23 18:30:22 +0200454/*
Emeric Brunb3971ab2015-05-12 18:49:09 +0200455 * This prepare the data update message on the stick session <ts>, <st> is the considered
456 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800457 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200458 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
459 * check size)
Emeric Brun2b920a12010-09-23 18:30:22 +0200460 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100461static int peer_prepare_updatemsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brun2b920a12010-09-23 18:30:22 +0200462{
463 uint32_t netinteger;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200464 unsigned short datalen;
465 char *cursor, *datamsg;
Emeric Brun94900952015-06-11 18:25:54 +0200466 unsigned int data_type;
467 void *data_ptr;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100468 struct stksess *ts;
469 struct shared_table *st;
470 unsigned int updateid;
471 int use_identifier;
472 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200473 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100474
475 ts = p->updt.stksess;
476 st = p->updt.shared_table;
477 updateid = p->updt.updateid;
478 use_identifier = p->updt.use_identifier;
479 use_timed = p->updt.use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200480 peer = p->updt.peer;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200481
Frédéric Lécaille0e8db972019-05-24 14:34:34 +0200482 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200483
Emeric Brun2b920a12010-09-23 18:30:22 +0200484 /* construct message */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200485
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500486 /* check if we need to send the update identifier */
Emeric Brun819fc6f2017-06-13 19:37:32 +0200487 if (!st->last_pushed || updateid < st->last_pushed || ((updateid - st->last_pushed) != 1)) {
Emeric Bruna6a09982015-09-22 15:34:19 +0200488 use_identifier = 1;
Emeric Brun2b920a12010-09-23 18:30:22 +0200489 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200490
491 /* encode update identifier if needed */
492 if (use_identifier) {
Emeric Brun819fc6f2017-06-13 19:37:32 +0200493 netinteger = htonl(updateid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200494 memcpy(cursor, &netinteger, sizeof(netinteger));
495 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200496 }
497
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200498 if (use_timed) {
499 netinteger = htonl(tick_remain(now_ms, ts->expire));
500 memcpy(cursor, &netinteger, sizeof(netinteger));
501 cursor += sizeof(netinteger);
502 }
503
Emeric Brunb3971ab2015-05-12 18:49:09 +0200504 /* encode the key */
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200505 if (st->table->type == SMP_T_STR) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200506 int stlen = strlen((char *)ts->key.key);
507
Emeric Brunb3971ab2015-05-12 18:49:09 +0200508 intencode(stlen, &cursor);
509 memcpy(cursor, ts->key.key, stlen);
510 cursor += stlen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200511 }
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200512 else if (st->table->type == SMP_T_SINT) {
Willy Tarreau6cde5d82020-02-25 09:41:22 +0100513 netinteger = htonl(read_u32(ts->key.key));
Emeric Brunb3971ab2015-05-12 18:49:09 +0200514 memcpy(cursor, &netinteger, sizeof(netinteger));
515 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200516 }
517 else {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200518 memcpy(cursor, ts->key.key, st->table->key_size);
519 cursor += st->table->key_size;
Emeric Brun2b920a12010-09-23 18:30:22 +0200520 }
521
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100522 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200523 /* encode values */
Emeric Brun94900952015-06-11 18:25:54 +0200524 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200525
Emeric Brun94900952015-06-11 18:25:54 +0200526 data_ptr = stktable_data_ptr(st->table, ts, data_type);
527 if (data_ptr) {
528 switch (stktable_data_types[data_type].std_type) {
529 case STD_T_SINT: {
530 int data;
531
532 data = stktable_data_cast(data_ptr, std_t_sint);
533 intencode(data, &cursor);
534 break;
535 }
536 case STD_T_UINT: {
537 unsigned int data;
538
539 data = stktable_data_cast(data_ptr, std_t_uint);
540 intencode(data, &cursor);
541 break;
542 }
543 case STD_T_ULL: {
544 unsigned long long data;
545
546 data = stktable_data_cast(data_ptr, std_t_ull);
547 intencode(data, &cursor);
548 break;
549 }
550 case STD_T_FRQP: {
551 struct freq_ctr_period *frqp;
552
553 frqp = &stktable_data_cast(data_ptr, std_t_frqp);
554 intencode((unsigned int)(now_ms - frqp->curr_tick), &cursor);
555 intencode(frqp->curr_ctr, &cursor);
556 intencode(frqp->prev_ctr, &cursor);
557 break;
558 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200559 case STD_T_DICT: {
560 struct dict_entry *de;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200561 struct ebpt_node *cached_de;
Willy Tarreau237f8ae2019-06-06 16:40:43 +0200562 struct dcache_tx_entry cde = { };
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200563 char *beg, *end;
564 size_t value_len, data_len;
565 struct dcache *dc;
566
567 de = stktable_data_cast(data_ptr, std_t_dict);
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100568 if (!de) {
569 /* No entry */
570 intencode(0, &cursor);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200571 break;
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100572 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200573
574 dc = peer->dcache;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200575 cde.entry.key = de;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200576 cached_de = dcache_tx_insert(dc, &cde);
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200577 if (cached_de == &cde.entry) {
578 if (cde.id + 1 >= PEER_ENC_2BYTES_MIN)
579 break;
580 /* Encode the length of the remaining data -> 1 */
581 intencode(1, &cursor);
582 /* Encode the cache entry ID */
583 intencode(cde.id + 1, &cursor);
584 }
585 else {
586 /* Leave enough room to encode the remaining data length. */
587 end = beg = cursor + PEER_MSG_ENC_LENGTH_MAXLEN;
588 /* Encode the dictionary entry key */
589 intencode(cde.id + 1, &end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200590 /* Encode the length of the dictionary entry data */
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200591 value_len = de->len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200592 intencode(value_len, &end);
593 /* Copy the data */
594 memcpy(end, de->value.key, value_len);
595 end += value_len;
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200596 /* Encode the length of the data */
597 data_len = end - beg;
598 intencode(data_len, &cursor);
599 memmove(cursor, beg, data_len);
600 cursor += data_len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200601 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200602 break;
603 }
Emeric Brun94900952015-06-11 18:25:54 +0200604 }
605 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200606 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100607 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200608
609 /* Compute datalen */
610 datalen = (cursor - datamsg);
611
612 /* prepare message header */
613 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200614 peer_set_update_msg_type(&msg[1], use_identifier, use_timed);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200615 cursor = &msg[2];
616 intencode(datalen, &cursor);
617
618 /* move data after header */
619 memmove(cursor, datamsg, datalen);
620
621 /* return header size + data_len */
622 return (cursor - msg) + datalen;
623}
624
625/*
626 * This prepare the switch table message to targeted share table <st>.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800627 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200628 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
629 * check size)
630 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100631static int peer_prepare_switchmsg(char *msg, size_t size, struct peer_prep_params *params)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200632{
633 int len;
634 unsigned short datalen;
Willy Tarreau83061a82018-07-13 11:56:34 +0200635 struct buffer *chunk;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200636 char *cursor, *datamsg, *chunkp, *chunkq;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200637 uint64_t data = 0;
Emeric Brun94900952015-06-11 18:25:54 +0200638 unsigned int data_type;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100639 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200640
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100641 st = params->swtch.shared_table;
Frédéric Lécaille39143342019-05-24 14:32:27 +0200642 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200643
644 /* Encode data */
645
646 /* encode local id */
647 intencode(st->local_id, &cursor);
648
649 /* encode table name */
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100650 len = strlen(st->table->nid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200651 intencode(len, &cursor);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100652 memcpy(cursor, st->table->nid, len);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200653 cursor += len;
654
655 /* encode table type */
656
Emeric Brun530ba382020-06-02 11:17:42 +0200657 intencode(peer_net_key_type[st->table->type], &cursor);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200658
659 /* encode table key size */
660 intencode(st->table->key_size, &cursor);
661
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200662 chunk = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200663 chunkp = chunkq = chunk->area;
Emeric Brun94900952015-06-11 18:25:54 +0200664 /* encode available known data types in table */
665 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
666 if (st->table->data_ofs[data_type]) {
667 switch (stktable_data_types[data_type].std_type) {
668 case STD_T_SINT:
669 case STD_T_UINT:
670 case STD_T_ULL:
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200671 case STD_T_DICT:
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200672 data |= 1 << data_type;
673 break;
Emeric Brun94900952015-06-11 18:25:54 +0200674 case STD_T_FRQP:
675 data |= 1 << data_type;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200676 intencode(data_type, &chunkq);
677 intencode(st->table->data_arg[data_type].u, &chunkq);
Emeric Brun94900952015-06-11 18:25:54 +0200678 break;
679 }
680 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200681 }
682 intencode(data, &cursor);
683
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200684 /* Encode stick-table entries duration. */
685 intencode(st->table->expire, &cursor);
686
687 if (chunkq > chunkp) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200688 chunk->data = chunkq - chunkp;
689 memcpy(cursor, chunk->area, chunk->data);
690 cursor += chunk->data;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200691 }
692
Emeric Brunb3971ab2015-05-12 18:49:09 +0200693 /* Compute datalen */
694 datalen = (cursor - datamsg);
Emeric Brun2b920a12010-09-23 18:30:22 +0200695
Emeric Brunb3971ab2015-05-12 18:49:09 +0200696 /* prepare message header */
697 msg[0] = PEER_MSG_CLASS_STICKTABLE;
698 msg[1] = PEER_MSG_STKT_DEFINE;
699 cursor = &msg[2];
700 intencode(datalen, &cursor);
Emeric Brun2b920a12010-09-23 18:30:22 +0200701
Emeric Brunb3971ab2015-05-12 18:49:09 +0200702 /* move data after header */
703 memmove(cursor, datamsg, datalen);
704
705 /* return header size + data_len */
706 return (cursor - msg) + datalen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200707}
708
Emeric Brunb3971ab2015-05-12 18:49:09 +0200709/*
710 * This prepare the acknowledge message on the stick session <ts>, <st> is the considered
711 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800712 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200713 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
714 * check size)
715 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100716static int peer_prepare_ackmsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200717{
718 unsigned short datalen;
719 char *cursor, *datamsg;
720 uint32_t netinteger;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100721 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200722
Frédéric Lécaille39143342019-05-24 14:32:27 +0200723 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200724
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100725 st = p->ack.shared_table;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200726 intencode(st->remote_id, &cursor);
727 netinteger = htonl(st->last_get);
728 memcpy(cursor, &netinteger, sizeof(netinteger));
729 cursor += sizeof(netinteger);
730
731 /* Compute datalen */
732 datalen = (cursor - datamsg);
733
734 /* prepare message header */
735 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Emeric Brune1ab8082015-08-21 11:48:54 +0200736 msg[1] = PEER_MSG_STKT_ACK;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200737 cursor = &msg[2];
738 intencode(datalen, &cursor);
739
740 /* move data after header */
741 memmove(cursor, datamsg, datalen);
742
743 /* return header size + data_len */
744 return (cursor - msg) + datalen;
745}
Emeric Brun2b920a12010-09-23 18:30:22 +0200746
747/*
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200748 * Function to deinit connected peer
749 */
750void __peer_session_deinit(struct peer *peer)
751{
752 struct stream_interface *si;
753 struct stream *s;
754 struct peers *peers;
755
756 if (!peer->appctx)
757 return;
758
759 si = peer->appctx->owner;
760 if (!si)
761 return;
762
763 s = si_strm(si);
764 if (!s)
765 return;
766
767 peers = strm_fe(s)->parent;
768 if (!peers)
769 return;
770
771 if (peer->appctx->st0 == PEER_SESS_ST_WAITMSG)
772 HA_ATOMIC_SUB(&connected_peers, 1);
773
774 HA_ATOMIC_SUB(&active_peers, 1);
775
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200776 flush_dcache(peer);
777
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200778 /* Re-init current table pointers to force announcement on re-connect */
779 peer->remote_table = peer->last_local_table = NULL;
780 peer->appctx = NULL;
781 if (peer->flags & PEER_F_LEARN_ASSIGN) {
782 /* unassign current peer for learning */
783 peer->flags &= ~(PEER_F_LEARN_ASSIGN);
784 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
785
786 /* reschedule a resync */
787 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
788 }
789 /* reset teaching and learning flags to 0 */
790 peer->flags &= PEER_TEACH_RESET;
791 peer->flags &= PEER_LEARN_RESET;
Frédéric Lécaille3585cab2019-11-20 11:17:30 +0100792 /* set this peer as dead from heartbeat point of view */
793 peer->flags &= ~PEER_F_ALIVE;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200794 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
795}
796
797/*
Emeric Brun2b920a12010-09-23 18:30:22 +0200798 * Callback to release a session with a peer
799 */
Willy Tarreau00a37f02015-04-13 12:05:19 +0200800static void peer_session_release(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +0200801{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200802 struct peer *peer = appctx->ctx.peers.ptr;
Emeric Brun2b920a12010-09-23 18:30:22 +0200803
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100804 /* appctx->ctx.peers.ptr is not a peer session */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100805 if (appctx->st0 < PEER_SESS_ST_SENDSUCCESS)
Emeric Brun2b920a12010-09-23 18:30:22 +0200806 return;
807
808 /* peer session identified */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200809 if (peer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100810 HA_SPIN_LOCK(PEER_LOCK, &peer->lock);
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200811 if (peer->appctx == appctx)
812 __peer_session_deinit(peer);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100813 HA_SPIN_UNLOCK(PEER_LOCK, &peer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +0200814 }
815}
816
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200817/* Retrieve the major and minor versions of peers protocol
818 * announced by a remote peer. <str> is a null-terminated
819 * string with the following format: "<maj_ver>.<min_ver>".
820 */
821static int peer_get_version(const char *str,
822 unsigned int *maj_ver, unsigned int *min_ver)
823{
824 unsigned int majv, minv;
825 const char *pos, *saved;
826 const char *end;
827
828 saved = pos = str;
829 end = str + strlen(str);
830
831 majv = read_uint(&pos, end);
832 if (saved == pos || *pos++ != '.')
833 return -1;
834
835 saved = pos;
836 minv = read_uint(&pos, end);
837 if (saved == pos || pos != end)
838 return -1;
839
840 *maj_ver = majv;
841 *min_ver = minv;
842
843 return 0;
844}
Emeric Brun2b920a12010-09-23 18:30:22 +0200845
846/*
Frédéric Lécaillece025572019-01-21 13:38:06 +0100847 * Parse a line terminated by an optional '\r' character, followed by a mandatory
848 * '\n' character.
849 * Returns 1 if succeeded or 0 if a '\n' character could not be found, and -1 if
850 * a line could not be read because the communication channel is closed.
851 */
852static inline int peer_getline(struct appctx *appctx)
853{
854 int n;
855 struct stream_interface *si = appctx->owner;
856
857 n = co_getline(si_oc(si), trash.area, trash.size);
858 if (!n)
859 return 0;
860
861 if (n < 0 || trash.area[n - 1] != '\n') {
862 appctx->st0 = PEER_SESS_ST_END;
863 return -1;
864 }
865
866 if (n > 1 && (trash.area[n - 2] == '\r'))
867 trash.area[n - 2] = 0;
868 else
869 trash.area[n - 1] = 0;
870
871 co_skip(si_oc(si), n);
872
873 return n;
874}
875
876/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100877 * Send a message after having called <peer_prepare_msg> to build it.
878 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
879 * Returns -1 if there was not enough room left to send the message,
880 * any other negative returned value must be considered as an error with an appcxt st0
881 * returned value equal to PEER_SESS_ST_END.
882 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100883static inline int peer_send_msg(struct appctx *appctx,
884 int (*peer_prepare_msg)(char *, size_t, struct peer_prep_params *),
885 struct peer_prep_params *params)
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100886{
887 int ret, msglen;
888 struct stream_interface *si = appctx->owner;
889
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100890 msglen = peer_prepare_msg(trash.area, trash.size, params);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100891 if (!msglen) {
892 /* internal error: message does not fit in trash */
893 appctx->st0 = PEER_SESS_ST_END;
894 return 0;
895 }
896
897 /* message to buffer */
898 ret = ci_putblk(si_ic(si), trash.area, msglen);
899 if (ret <= 0) {
900 if (ret == -1) {
901 /* No more write possible */
902 si_rx_room_blk(si);
903 return -1;
904 }
905 appctx->st0 = PEER_SESS_ST_END;
906 }
907
908 return ret;
909}
910
911/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100912 * Send a hello message.
913 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
914 * Returns -1 if there was not enough room left to send the message,
915 * any other negative returned value must be considered as an error with an appcxt st0
916 * returned value equal to PEER_SESS_ST_END.
917 */
918static inline int peer_send_hellomsg(struct appctx *appctx, struct peer *peer)
919{
920 struct peer_prep_params p = {
921 .hello.peer = peer,
922 };
923
924 return peer_send_msg(appctx, peer_prepare_hellomsg, &p);
925}
926
927/*
928 * Send a success peer handshake status message.
929 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
930 * Returns -1 if there was not enough room left to send the message,
931 * any other negative returned value must be considered as an error with an appcxt st0
932 * returned value equal to PEER_SESS_ST_END.
933 */
934static inline int peer_send_status_successmsg(struct appctx *appctx)
935{
936 return peer_send_msg(appctx, peer_prepare_status_successmsg, NULL);
937}
938
939/*
940 * Send a peer handshake status error message.
941 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
942 * Returns -1 if there was not enough room left to send the message,
943 * any other negative returned value must be considered as an error with an appcxt st0
944 * returned value equal to PEER_SESS_ST_END.
945 */
946static inline int peer_send_status_errormsg(struct appctx *appctx)
947{
948 struct peer_prep_params p = {
949 .error_status.st1 = appctx->st1,
950 };
951
952 return peer_send_msg(appctx, peer_prepare_status_errormsg, &p);
953}
954
955/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100956 * Send a stick-table switch message.
957 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
958 * Returns -1 if there was not enough room left to send the message,
959 * any other negative returned value must be considered as an error with an appcxt st0
960 * returned value equal to PEER_SESS_ST_END.
961 */
962static inline int peer_send_switchmsg(struct shared_table *st, struct appctx *appctx)
963{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100964 struct peer_prep_params p = {
965 .swtch.shared_table = st,
966 };
967
968 return peer_send_msg(appctx, peer_prepare_switchmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100969}
970
971/*
972 * Send a stick-table update acknowledgement message.
973 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
974 * Returns -1 if there was not enough room left to send the message,
975 * any other negative returned value must be considered as an error with an appcxt st0
976 * returned value equal to PEER_SESS_ST_END.
977 */
978static inline int peer_send_ackmsg(struct shared_table *st, struct appctx *appctx)
979{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100980 struct peer_prep_params p = {
981 .ack.shared_table = st,
982 };
983
984 return peer_send_msg(appctx, peer_prepare_ackmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100985}
986
987/*
Frédéric Lécaille87f554c2019-01-22 17:26:50 +0100988 * Send a stick-table update message.
989 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
990 * Returns -1 if there was not enough room left to send the message,
991 * any other negative returned value must be considered as an error with an appcxt st0
992 * returned value equal to PEER_SESS_ST_END.
993 */
994static inline int peer_send_updatemsg(struct shared_table *st, struct appctx *appctx, struct stksess *ts,
995 unsigned int updateid, int use_identifier, int use_timed)
996{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100997 struct peer_prep_params p = {
Willy Tarreaua898f0c2020-07-03 19:09:29 +0200998 .updt = {
999 .stksess = ts,
1000 .shared_table = st,
1001 .updateid = updateid,
1002 .use_identifier = use_identifier,
1003 .use_timed = use_timed,
1004 .peer = appctx->ctx.peers.ptr,
1005 },
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001006 };
1007
1008 return peer_send_msg(appctx, peer_prepare_updatemsg, &p);
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001009}
1010
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001011/*
1012 * Build a peer protocol control class message.
1013 * Returns the number of written bytes used to build the message if succeeded,
1014 * 0 if not.
1015 */
1016static int peer_prepare_control_msg(char *msg, size_t size, struct peer_prep_params *p)
1017{
1018 if (size < sizeof p->control.head)
1019 return 0;
1020
1021 msg[0] = p->control.head[0];
1022 msg[1] = p->control.head[1];
1023
1024 return 2;
1025}
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001026
1027/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001028 * Send a stick-table synchronization request message.
1029 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1030 * Returns -1 if there was not enough room left to send the message,
1031 * any other negative returned value must be considered as an error with an appctx st0
1032 * returned value equal to PEER_SESS_ST_END.
1033 */
1034static inline int peer_send_resync_reqmsg(struct appctx *appctx)
1035{
1036 struct peer_prep_params p = {
1037 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCREQ, },
1038 };
1039
1040 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1041}
1042
1043/*
1044 * Send a stick-table synchronization confirmation message.
1045 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1046 * Returns -1 if there was not enough room left to send the message,
1047 * any other negative returned value must be considered as an error with an appctx st0
1048 * returned value equal to PEER_SESS_ST_END.
1049 */
1050static inline int peer_send_resync_confirmsg(struct appctx *appctx)
1051{
1052 struct peer_prep_params p = {
1053 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCCONFIRM, },
1054 };
1055
1056 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1057}
1058
1059/*
1060 * Send a stick-table synchronization finished message.
1061 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1062 * Returns -1 if there was not enough room left to send the message,
1063 * any other negative returned value must be considered as an error with an appctx st0
1064 * returned value equal to PEER_SESS_ST_END.
1065 */
Emeric Brun70de43b2020-03-16 10:51:01 +01001066static inline int peer_send_resync_finishedmsg(struct appctx *appctx, struct peers *peers)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001067{
1068 struct peer_prep_params p = {
1069 .control.head = { PEER_MSG_CLASS_CONTROL, },
1070 };
1071
Emeric Brun70de43b2020-03-16 10:51:01 +01001072 p.control.head[1] = (peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED ?
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001073 PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
1074
1075 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1076}
1077
1078/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001079 * Send a heartbeat message.
1080 * Return 0 if the message could not be built modifying the appctx st0 to PEER_SESS_ST_END value.
1081 * Returns -1 if there was not enough room left to send the message,
1082 * any other negative returned value must be considered as an error with an appctx st0
1083 * returned value equal to PEER_SESS_ST_END.
1084 */
1085static inline int peer_send_heartbeatmsg(struct appctx *appctx)
1086{
1087 struct peer_prep_params p = {
1088 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_HEARTBEAT, },
1089 };
1090
1091 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1092}
1093
1094/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001095 * Build a peer protocol error class message.
1096 * Returns the number of written bytes used to build the message if succeeded,
1097 * 0 if not.
1098 */
1099static int peer_prepare_error_msg(char *msg, size_t size, struct peer_prep_params *p)
1100{
1101 if (size < sizeof p->error.head)
1102 return 0;
1103
1104 msg[0] = p->error.head[0];
1105 msg[1] = p->error.head[1];
1106
1107 return 2;
1108}
1109
1110/*
1111 * Send a "size limit reached" error message.
1112 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1113 * Returns -1 if there was not enough room left to send the message,
1114 * any other negative returned value must be considered as an error with an appctx st0
1115 * returned value equal to PEER_SESS_ST_END.
1116 */
1117static inline int peer_send_error_size_limitmsg(struct appctx *appctx)
1118{
1119 struct peer_prep_params p = {
1120 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_SIZELIMIT, },
1121 };
1122
1123 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1124}
1125
1126/*
1127 * Send a "peer protocol" error message.
1128 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1129 * Returns -1 if there was not enough room left to send the message,
1130 * any other negative returned value must be considered as an error with an appctx st0
1131 * returned value equal to PEER_SESS_ST_END.
1132 */
1133static inline int peer_send_error_protomsg(struct appctx *appctx)
1134{
1135 struct peer_prep_params p = {
1136 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_PROTOCOL, },
1137 };
1138
1139 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1140}
1141
1142/*
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001143 * Function used to lookup for recent stick-table updates associated with
1144 * <st> shared stick-table when a lesson must be taught a peer (PEER_F_LEARN_ASSIGN flag set).
1145 */
1146static inline struct stksess *peer_teach_process_stksess_lookup(struct shared_table *st)
1147{
1148 struct eb32_node *eb;
1149
1150 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1151 if (!eb) {
1152 eb = eb32_first(&st->table->updates);
1153 if (!eb || ((int)(eb->key - st->last_pushed) <= 0)) {
1154 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1155 return NULL;
1156 }
1157 }
1158
1159 if ((int)(eb->key - st->table->localupdate) > 0) {
1160 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1161 return NULL;
1162 }
1163
1164 return eb32_entry(eb, struct stksess, upd);
1165}
1166
1167/*
1168 * Function used to lookup for recent stick-table updates associated with
1169 * <st> shared stick-table during teach state 1 step.
1170 */
1171static inline struct stksess *peer_teach_stage1_stksess_lookup(struct shared_table *st)
1172{
1173 struct eb32_node *eb;
1174
1175 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1176 if (!eb) {
1177 st->flags |= SHTABLE_F_TEACH_STAGE1;
1178 eb = eb32_first(&st->table->updates);
1179 if (eb)
1180 st->last_pushed = eb->key - 1;
1181 return NULL;
1182 }
1183
1184 return eb32_entry(eb, struct stksess, upd);
1185}
1186
1187/*
1188 * Function used to lookup for recent stick-table updates associated with
1189 * <st> shared stick-table during teach state 2 step.
1190 */
1191static inline struct stksess *peer_teach_stage2_stksess_lookup(struct shared_table *st)
1192{
1193 struct eb32_node *eb;
1194
1195 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1196 if (!eb || eb->key > st->teaching_origin) {
1197 st->flags |= SHTABLE_F_TEACH_STAGE2;
1198 return NULL;
1199 }
1200
1201 return eb32_entry(eb, struct stksess, upd);
1202}
1203
1204/*
1205 * Generic function to emit update messages for <st> stick-table when a lesson must
1206 * be taught to the peer <p>.
1207 * <locked> must be set to 1 if the shared table <st> is already locked when entering
1208 * this function, 0 if not.
1209 *
1210 * This function temporary unlock/lock <st> when it sends stick-table updates or
1211 * when decrementing its refcount in case of any error when it sends this updates.
1212 *
1213 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1214 * Returns -1 if there was not enough room left to send the message,
1215 * any other negative returned value must be considered as an error with an appcxt st0
1216 * returned value equal to PEER_SESS_ST_END.
1217 * If it returns 0 or -1, this function leave <st> locked if already locked when entering this function
1218 * unlocked if not already locked when entering this function.
1219 */
1220static inline int peer_send_teachmsgs(struct appctx *appctx, struct peer *p,
1221 struct stksess *(*peer_stksess_lookup)(struct shared_table *),
1222 struct shared_table *st, int locked)
1223{
1224 int ret, new_pushed, use_timed;
1225
1226 ret = 1;
1227 use_timed = 0;
1228 if (st != p->last_local_table) {
1229 ret = peer_send_switchmsg(st, appctx);
1230 if (ret <= 0)
1231 return ret;
1232
1233 p->last_local_table = st;
1234 }
1235
1236 if (peer_stksess_lookup != peer_teach_process_stksess_lookup)
1237 use_timed = !(p->flags & PEER_F_DWNGRD);
1238
1239 /* We force new pushed to 1 to force identifier in update message */
1240 new_pushed = 1;
1241
1242 if (!locked)
1243 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1244
1245 while (1) {
1246 struct stksess *ts;
1247 unsigned updateid;
1248
1249 /* push local updates */
1250 ts = peer_stksess_lookup(st);
1251 if (!ts)
1252 break;
1253
1254 updateid = ts->upd.key;
1255 ts->ref_cnt++;
1256 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1257
1258 ret = peer_send_updatemsg(st, appctx, ts, updateid, new_pushed, use_timed);
1259 if (ret <= 0) {
1260 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1261 ts->ref_cnt--;
1262 if (!locked)
1263 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1264 return ret;
1265 }
1266
1267 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1268 ts->ref_cnt--;
1269 st->last_pushed = updateid;
1270
1271 if (peer_stksess_lookup == peer_teach_process_stksess_lookup &&
1272 (int)(st->last_pushed - st->table->commitupdate) > 0)
1273 st->table->commitupdate = st->last_pushed;
1274
1275 /* identifier may not needed in next update message */
1276 new_pushed = 0;
1277 }
1278
1279 out:
1280 if (!locked)
1281 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1282 return 1;
1283}
1284
1285/*
1286 * Function to emit update messages for <st> stick-table when a lesson must
1287 * be taught to the peer <p> (PEER_F_LEARN_ASSIGN flag set).
1288 *
1289 * Note that <st> shared stick-table is locked when calling this function.
1290 *
1291 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1292 * Returns -1 if there was not enough room left to send the message,
1293 * any other negative returned value must be considered as an error with an appcxt st0
1294 * returned value equal to PEER_SESS_ST_END.
1295 */
1296static inline int peer_send_teach_process_msgs(struct appctx *appctx, struct peer *p,
1297 struct shared_table *st)
1298{
1299 return peer_send_teachmsgs(appctx, p, peer_teach_process_stksess_lookup, st, 1);
1300}
1301
1302/*
1303 * Function to emit update messages for <st> stick-table when a lesson must
1304 * be taught to the peer <p> during teach state 1 step.
1305 *
1306 * Return 0 if any 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 appcxt st0
1309 * returned value equal to PEER_SESS_ST_END.
1310 */
1311static inline int peer_send_teach_stage1_msgs(struct appctx *appctx, struct peer *p,
1312 struct shared_table *st)
1313{
1314 return peer_send_teachmsgs(appctx, p, peer_teach_stage1_stksess_lookup, st, 0);
1315}
1316
1317/*
1318 * Function to emit update messages for <st> stick-table when a lesson must
1319 * be taught to the peer <p> during teach state 1 step.
1320 *
1321 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1322 * Returns -1 if there was not enough room left to send the message,
1323 * any other negative returned value must be considered as an error with an appcxt st0
1324 * returned value equal to PEER_SESS_ST_END.
1325 */
1326static inline int peer_send_teach_stage2_msgs(struct appctx *appctx, struct peer *p,
1327 struct shared_table *st)
1328{
1329 return peer_send_teachmsgs(appctx, p, peer_teach_stage2_stksess_lookup, st, 0);
1330}
1331
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001332
1333/*
1334 * Function used to parse a stick-table update message after it has been received
1335 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1336 * receipt buffer with <msg_end> being position of the end of the stick-table message.
1337 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1338 * was encountered.
1339 * <exp> must be set if the stick-table entry expires.
1340 * <updt> must be set for PEER_MSG_STKT_UPDATE or PEER_MSG_STKT_UPDATE_TIMED stick-table
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001341 * 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 +01001342 * update ID.
1343 * <totl> is the length of the stick-table update message computed upon receipt.
1344 */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001345static int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int exp,
1346 char **msg_cur, char *msg_end, int msg_len, int totl)
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001347{
1348 struct stream_interface *si = appctx->owner;
1349 struct shared_table *st = p->remote_table;
1350 struct stksess *ts, *newts;
1351 uint32_t update;
1352 int expire;
1353 unsigned int data_type;
1354 void *data_ptr;
1355
1356 /* Here we have data message */
1357 if (!st)
1358 goto ignore_msg;
1359
1360 expire = MS_TO_TICKS(st->table->expire);
1361
1362 if (updt) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001363 if (msg_len < sizeof(update))
1364 goto malformed_exit;
1365
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001366 memcpy(&update, *msg_cur, sizeof(update));
1367 *msg_cur += sizeof(update);
1368 st->last_get = htonl(update);
1369 }
1370 else {
1371 st->last_get++;
1372 }
1373
1374 if (exp) {
1375 size_t expire_sz = sizeof expire;
1376
Willy Tarreau1e82a142019-01-29 11:08:06 +01001377 if (*msg_cur + expire_sz > msg_end)
1378 goto malformed_exit;
1379
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001380 memcpy(&expire, *msg_cur, expire_sz);
1381 *msg_cur += expire_sz;
1382 expire = ntohl(expire);
1383 }
1384
1385 newts = stksess_new(st->table, NULL);
1386 if (!newts)
1387 goto ignore_msg;
1388
1389 if (st->table->type == SMP_T_STR) {
1390 unsigned int to_read, to_store;
1391
1392 to_read = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001393 if (!*msg_cur)
1394 goto malformed_free_newts;
1395
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001396 to_store = MIN(to_read, st->table->key_size - 1);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001397 if (*msg_cur + to_store > msg_end)
1398 goto malformed_free_newts;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001399
1400 memcpy(newts->key.key, *msg_cur, to_store);
1401 newts->key.key[to_store] = 0;
1402 *msg_cur += to_read;
1403 }
1404 else if (st->table->type == SMP_T_SINT) {
1405 unsigned int netinteger;
1406
Willy Tarreau1e82a142019-01-29 11:08:06 +01001407 if (*msg_cur + sizeof(netinteger) > msg_end)
1408 goto malformed_free_newts;
1409
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001410 memcpy(&netinteger, *msg_cur, sizeof(netinteger));
1411 netinteger = ntohl(netinteger);
1412 memcpy(newts->key.key, &netinteger, sizeof(netinteger));
1413 *msg_cur += sizeof(netinteger);
1414 }
1415 else {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001416 if (*msg_cur + st->table->key_size > msg_end)
1417 goto malformed_free_newts;
1418
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001419 memcpy(newts->key.key, *msg_cur, st->table->key_size);
1420 *msg_cur += st->table->key_size;
1421 }
1422
1423 /* lookup for existing entry */
1424 ts = stktable_set_entry(st->table, newts);
1425 if (ts != newts) {
1426 stksess_free(st->table, newts);
1427 newts = NULL;
1428 }
1429
1430 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
1431
1432 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001433 uint64_t decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001434
1435 if (!((1 << data_type) & st->remote_data))
1436 continue;
1437
Willy Tarreau1e82a142019-01-29 11:08:06 +01001438 decoded_int = intdecode(msg_cur, msg_end);
1439 if (!*msg_cur)
1440 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001441
Willy Tarreau1e82a142019-01-29 11:08:06 +01001442 switch (stktable_data_types[data_type].std_type) {
1443 case STD_T_SINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001444 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1445 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001446 stktable_data_cast(data_ptr, std_t_sint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001447 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001448
Willy Tarreau1e82a142019-01-29 11:08:06 +01001449 case STD_T_UINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001450 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1451 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001452 stktable_data_cast(data_ptr, std_t_uint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001453 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001454
Willy Tarreau1e82a142019-01-29 11:08:06 +01001455 case STD_T_ULL:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001456 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1457 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001458 stktable_data_cast(data_ptr, std_t_ull) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001459 break;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001460
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001461 case STD_T_FRQP: {
1462 struct freq_ctr_period data;
1463
1464 /* First bit is reserved for the freq_ctr_period lock
1465 Note: here we're still protected by the stksess lock
1466 so we don't need to update the update the freq_ctr_period
1467 using its internal lock */
1468
Willy Tarreau1e82a142019-01-29 11:08:06 +01001469 data.curr_tick = tick_add(now_ms, -decoded_int) & ~0x1;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001470 data.curr_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001471 if (!*msg_cur)
1472 goto malformed_unlock;
1473
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001474 data.prev_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001475 if (!*msg_cur)
1476 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001477
1478 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1479 if (data_ptr)
1480 stktable_data_cast(data_ptr, std_t_frqp) = data;
1481 break;
1482 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001483 case STD_T_DICT: {
1484 struct buffer *chunk;
1485 size_t data_len, value_len;
1486 unsigned int id;
1487 struct dict_entry *de;
1488 struct dcache *dc;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001489 char *end;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001490
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +01001491 if (!decoded_int) {
1492 /* No entry. */
1493 break;
1494 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001495 data_len = decoded_int;
1496 if (*msg_cur + data_len > msg_end)
1497 goto malformed_unlock;
1498
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001499 /* Compute the end of the current data, <msg_end> being at the end of
1500 * the entire message.
1501 */
1502 end = *msg_cur + data_len;
1503 id = intdecode(msg_cur, end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001504 if (!*msg_cur || !id)
1505 goto malformed_unlock;
1506
1507 dc = p->dcache;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001508 if (*msg_cur == end) {
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001509 /* Dictionary entry key without value. */
1510 if (id > dc->max_entries)
1511 break;
1512 /* IDs sent over the network are numbered from 1. */
1513 de = dc->rx[id - 1].de;
1514 }
1515 else {
1516 chunk = get_trash_chunk();
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001517 value_len = intdecode(msg_cur, end);
1518 if (!*msg_cur || *msg_cur + value_len > end ||
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001519 unlikely(value_len + 1 >= chunk->size))
1520 goto malformed_unlock;
1521
1522 chunk_memcpy(chunk, *msg_cur, value_len);
1523 chunk->area[chunk->data] = '\0';
Frédéric Lécaille56aec0d2019-06-06 14:14:15 +02001524 *msg_cur += value_len;
1525
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001526 de = dict_insert(&server_name_dict, chunk->area);
1527 dc->rx[id - 1].de = de;
1528 }
1529 if (de) {
1530 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1531 if (data_ptr)
1532 stktable_data_cast(data_ptr, std_t_dict) = de;
1533 }
1534 break;
1535 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001536 }
1537 }
1538 /* Force new expiration */
1539 ts->expire = tick_add(now_ms, expire);
1540
1541 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1542 stktable_touch_remote(st->table, ts, 1);
1543 return 1;
1544
1545 ignore_msg:
1546 /* skip consumed message */
1547 co_skip(si_oc(si), totl);
1548 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001549
1550 malformed_unlock:
1551 /* malformed message */
1552 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1553 stktable_touch_remote(st->table, ts, 1);
1554 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1555 return 0;
1556
1557 malformed_free_newts:
1558 /* malformed message */
1559 stksess_free(st->table, newts);
1560 malformed_exit:
1561 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1562 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001563}
1564
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001565/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001566 * Function used to parse a stick-table update acknowledgement message after it
1567 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1568 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1569 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1570 * was encountered.
1571 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1572 */
1573static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1574 char **msg_cur, char *msg_end)
1575{
1576 /* ack message */
1577 uint32_t table_id ;
1578 uint32_t update;
1579 struct shared_table *st;
1580
1581 table_id = intdecode(msg_cur, msg_end);
1582 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1583 /* malformed message */
1584 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1585 return 0;
1586 }
1587
1588 memcpy(&update, *msg_cur, sizeof(update));
1589 update = ntohl(update);
1590
1591 for (st = p->tables; st; st = st->next) {
1592 if (st->local_id == table_id) {
1593 st->update = update;
1594 break;
1595 }
1596 }
1597
1598 return 1;
1599}
1600
1601/*
1602 * Function used to parse a stick-table switch message after it has been received
1603 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1604 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1605 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1606 * was encountered.
1607 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1608 */
1609static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1610 char **msg_cur, char *msg_end)
1611{
1612 struct shared_table *st;
1613 int table_id;
1614
1615 table_id = intdecode(msg_cur, msg_end);
1616 if (!*msg_cur) {
1617 /* malformed message */
1618 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1619 return 0;
1620 }
1621
1622 p->remote_table = NULL;
1623 for (st = p->tables; st; st = st->next) {
1624 if (st->remote_id == table_id) {
1625 p->remote_table = st;
1626 break;
1627 }
1628 }
1629
1630 return 1;
1631}
1632
1633/*
1634 * Function used to parse a stick-table definition message after it has been received
1635 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1636 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1637 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1638 * was encountered.
1639 * <totl> is the length of the stick-table update message computed upon receipt.
1640 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1641 */
1642static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1643 char **msg_cur, char *msg_end, int totl)
1644{
1645 struct stream_interface *si = appctx->owner;
1646 int table_id_len;
1647 struct shared_table *st;
1648 int table_type;
1649 int table_keylen;
1650 int table_id;
1651 uint64_t table_data;
1652
1653 table_id = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001654 if (!*msg_cur)
1655 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001656
1657 table_id_len = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001658 if (!*msg_cur)
1659 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001660
1661 p->remote_table = NULL;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001662 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end)
1663 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001664
1665 for (st = p->tables; st; st = st->next) {
1666 /* Reset IDs */
1667 if (st->remote_id == table_id)
1668 st->remote_id = 0;
1669
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001670 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1671 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001672 p->remote_table = st;
1673 }
1674
1675 if (!p->remote_table)
1676 goto ignore_msg;
1677
1678 *msg_cur += table_id_len;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001679 if (*msg_cur >= msg_end)
1680 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001681
1682 table_type = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001683 if (!*msg_cur)
1684 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001685
1686 table_keylen = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001687 if (!*msg_cur)
1688 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001689
1690 table_data = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001691 if (!*msg_cur)
1692 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001693
Emeric Brun530ba382020-06-02 11:17:42 +02001694 if (p->remote_table->table->type != peer_int_key_type[table_type]
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001695 || p->remote_table->table->key_size != table_keylen) {
1696 p->remote_table = NULL;
1697 goto ignore_msg;
1698 }
1699
1700 p->remote_table->remote_data = table_data;
1701 p->remote_table->remote_id = table_id;
1702 return 1;
1703
1704 ignore_msg:
1705 co_skip(si_oc(si), totl);
1706 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001707
1708 malformed_exit:
1709 /* malformed message */
1710 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1711 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001712}
1713
1714/*
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001715 * Receive a stick-table message.
1716 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1717 * -1 if there was an error updating the appctx state st0 accordingly.
1718 */
1719static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1720 uint32_t *msg_len, int *totl)
1721{
1722 int reql;
1723 struct stream_interface *si = appctx->owner;
1724
1725 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1726 if (reql <= 0) /* closed or EOL not found */
1727 goto incomplete;
1728
1729 *totl += reql;
1730
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001731 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001732 return 1;
1733
1734 /* Read and Decode message length */
1735 reql = co_getblk(si_oc(si), &msg_head[2], sizeof(char), *totl);
1736 if (reql <= 0) /* closed */
1737 goto incomplete;
1738
1739 *totl += reql;
1740
Frédéric Lécaille32b55732019-06-03 18:29:51 +02001741 if ((unsigned int)msg_head[2] < PEER_ENC_2BYTES_MIN) {
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001742 *msg_len = msg_head[2];
1743 }
1744 else {
1745 int i;
1746 char *cur;
1747 char *end;
1748
1749 for (i = 3 ; i < msg_head_sz ; i++) {
1750 reql = co_getblk(si_oc(si), &msg_head[i], sizeof(char), *totl);
1751 if (reql <= 0) /* closed */
1752 goto incomplete;
1753
1754 *totl += reql;
1755
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001756 if (!(msg_head[i] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001757 break;
1758 }
1759
1760 if (i == msg_head_sz) {
1761 /* malformed message */
1762 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1763 return -1;
1764 }
1765 end = msg_head + msg_head_sz;
1766 cur = &msg_head[2];
1767 *msg_len = intdecode(&cur, end);
1768 if (!cur) {
1769 /* malformed message */
1770 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1771 return -1;
1772 }
1773 }
1774
1775 /* Read message content */
1776 if (*msg_len) {
1777 if (*msg_len > trash.size) {
1778 /* Status code is not success, abort */
1779 appctx->st0 = PEER_SESS_ST_ERRSIZE;
1780 return -1;
1781 }
1782
1783 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
1784 if (reql <= 0) /* closed */
1785 goto incomplete;
1786 *totl += reql;
1787 }
1788
1789 return 1;
1790
1791 incomplete:
1792 if (reql < 0) {
1793 /* there was an error */
1794 appctx->st0 = PEER_SESS_ST_END;
1795 return -1;
1796 }
1797
1798 return 0;
1799}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001800
1801/*
1802 * Treat the awaited message with <msg_head> as header.*
1803 * Return 1 if succeeded, 0 if not.
1804 */
1805static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
1806 char **msg_cur, char *msg_end, int msg_len, int totl)
1807{
1808 struct stream_interface *si = appctx->owner;
1809 struct stream *s = si_strm(si);
1810 struct peers *peers = strm_fe(s)->parent;
1811
1812 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
1813 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
1814 struct shared_table *st;
1815 /* Reset message: remote need resync */
1816
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001817 /* prepare tables for a global push */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001818 for (st = peer->tables; st; st = st->next) {
1819 st->teaching_origin = st->last_pushed = st->table->update;
1820 st->flags = 0;
1821 }
1822
1823 /* reset teaching flags to 0 */
1824 peer->flags &= PEER_TEACH_RESET;
1825
1826 /* flag to start to teach lesson */
1827 peer->flags |= PEER_F_TEACH_PROCESS;
1828 }
1829 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
1830 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1831 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1832 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1833 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
1834 }
1835 peer->confirm++;
1836 }
1837 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
1838 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1839 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1840 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1841
1842 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001843 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001844 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
1845 }
1846 peer->confirm++;
1847 }
1848 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
1849 struct shared_table *st;
1850
1851 /* If stopping state */
1852 if (stopping) {
1853 /* Close session, push resync no more needed */
1854 peer->flags |= PEER_F_TEACH_COMPLETE;
1855 appctx->st0 = PEER_SESS_ST_END;
1856 return 0;
1857 }
1858 for (st = peer->tables; st; st = st->next) {
1859 st->update = st->last_pushed = st->teaching_origin;
1860 st->flags = 0;
1861 }
1862
1863 /* reset teaching flags to 0 */
1864 peer->flags &= PEER_TEACH_RESET;
1865 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001866 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001867 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01001868 peer->rx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001869 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001870 }
1871 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
1872 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
1873 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
1874 return 0;
1875 }
1876 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
1877 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
1878 return 0;
1879 }
1880 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
1881 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
1882 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
1883 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
1884 int update, expire;
1885
1886 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
1887 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
1888 if (!peer_treat_updatemsg(appctx, peer, update, expire,
1889 msg_cur, msg_end, msg_len, totl))
1890 return 0;
1891
1892 }
1893 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
1894 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
1895 return 0;
1896 }
1897 }
1898 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
1899 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1900 return 0;
1901 }
1902
1903 return 1;
1904}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001905
1906
1907/*
1908 * Send any message to <peer> peer.
1909 * Returns 1 if succeeded, or -1 or 0 if failed.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001910 * -1 means an internal error occurred, 0 is for a peer protocol error leading
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001911 * to a peer state change (from the peer I/O handler point of view).
1912 */
1913static inline int peer_send_msgs(struct appctx *appctx, struct peer *peer)
1914{
1915 int repl;
1916 struct stream_interface *si = appctx->owner;
1917 struct stream *s = si_strm(si);
1918 struct peers *peers = strm_fe(s)->parent;
1919
1920 /* Need to request a resync */
1921 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
1922 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
1923 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
1924
1925 repl = peer_send_resync_reqmsg(appctx);
1926 if (repl <= 0)
1927 return repl;
1928
1929 peers->flags |= PEERS_F_RESYNC_PROCESS;
1930 }
1931
1932 /* Nothing to read, now we start to write */
1933 if (peer->tables) {
1934 struct shared_table *st;
1935 struct shared_table *last_local_table;
1936
1937 last_local_table = peer->last_local_table;
1938 if (!last_local_table)
1939 last_local_table = peer->tables;
1940 st = last_local_table->next;
1941
1942 while (1) {
1943 if (!st)
1944 st = peer->tables;
1945
1946 /* It remains some updates to ack */
1947 if (st->last_get != st->last_acked) {
1948 repl = peer_send_ackmsg(st, appctx);
1949 if (repl <= 0)
1950 return repl;
1951
1952 st->last_acked = st->last_get;
1953 }
1954
1955 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
1956 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1957 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
1958 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
1959
1960 repl = peer_send_teach_process_msgs(appctx, peer, st);
1961 if (repl <= 0) {
1962 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1963 return repl;
1964 }
1965 }
1966 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1967 }
1968 else {
1969 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
1970 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
1971 if (repl <= 0)
1972 return repl;
1973 }
1974
1975 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
1976 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
1977 if (repl <= 0)
1978 return repl;
1979 }
1980 }
1981
1982 if (st == last_local_table)
1983 break;
1984 st = st->next;
1985 }
1986 }
1987
1988 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
Emeric Brun70de43b2020-03-16 10:51:01 +01001989 repl = peer_send_resync_finishedmsg(appctx, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001990 if (repl <= 0)
1991 return repl;
1992
1993 /* flag finished message sent */
1994 peer->flags |= PEER_F_TEACH_FINISHED;
1995 }
1996
1997 /* Confirm finished or partial messages */
1998 while (peer->confirm) {
1999 repl = peer_send_resync_confirmsg(appctx);
2000 if (repl <= 0)
2001 return repl;
2002
2003 peer->confirm--;
2004 }
2005
2006 return 1;
2007}
2008
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002009/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002010 * Read and parse a first line of a "hello" peer protocol message.
2011 * Returns 0 if could not read a line, -1 if there was a read error or
2012 * the line is malformed, 1 if succeeded.
2013 */
2014static inline int peer_getline_version(struct appctx *appctx,
2015 unsigned int *maj_ver, unsigned int *min_ver)
2016{
2017 int reql;
2018
2019 reql = peer_getline(appctx);
2020 if (!reql)
2021 return 0;
2022
2023 if (reql < 0)
2024 return -1;
2025
2026 /* test protocol */
2027 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
2028 appctx->st0 = PEER_SESS_ST_EXIT;
2029 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2030 return -1;
2031 }
2032 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
2033 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
2034 appctx->st0 = PEER_SESS_ST_EXIT;
2035 appctx->st1 = PEER_SESS_SC_ERRVERSION;
2036 return -1;
2037 }
2038
2039 return 1;
2040}
2041
2042/*
2043 * Read and parse a second line of a "hello" peer protocol message.
2044 * Returns 0 if could not read a line, -1 if there was a read error or
2045 * the line is malformed, 1 if succeeded.
2046 */
2047static inline int peer_getline_host(struct appctx *appctx)
2048{
2049 int reql;
2050
2051 reql = peer_getline(appctx);
2052 if (!reql)
2053 return 0;
2054
2055 if (reql < 0)
2056 return -1;
2057
2058 /* test hostname match */
2059 if (strcmp(localpeer, trash.area) != 0) {
2060 appctx->st0 = PEER_SESS_ST_EXIT;
2061 appctx->st1 = PEER_SESS_SC_ERRHOST;
2062 return -1;
2063 }
2064
2065 return 1;
2066}
2067
2068/*
2069 * Read and parse a last line of a "hello" peer protocol message.
2070 * Returns 0 if could not read a character, -1 if there was a read error or
2071 * the line is malformed, 1 if succeeded.
2072 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2073 */
2074static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2075{
2076 char *p;
2077 int reql;
2078 struct peer *peer;
2079 struct stream_interface *si = appctx->owner;
2080 struct stream *s = si_strm(si);
2081 struct peers *peers = strm_fe(s)->parent;
2082
2083 reql = peer_getline(appctx);
2084 if (!reql)
2085 return 0;
2086
2087 if (reql < 0)
2088 return -1;
2089
2090 /* parse line "<peer name> <pid> <relative_pid>" */
2091 p = strchr(trash.area, ' ');
2092 if (!p) {
2093 appctx->st0 = PEER_SESS_ST_EXIT;
2094 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2095 return -1;
2096 }
2097 *p = 0;
2098
2099 /* lookup known peer */
2100 for (peer = peers->remote; peer; peer = peer->next) {
2101 if (strcmp(peer->id, trash.area) == 0)
2102 break;
2103 }
2104
2105 /* if unknown peer */
2106 if (!peer) {
2107 appctx->st0 = PEER_SESS_ST_EXIT;
2108 appctx->st1 = PEER_SESS_SC_ERRPEER;
2109 return -1;
2110 }
2111 *curpeer = peer;
2112
2113 return 1;
2114}
2115
2116/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002117 * Init <peer> peer after having accepted it at peer protocol level.
2118 */
2119static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2120{
2121 struct shared_table *st;
2122
2123 /* Register status code */
2124 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
2125
2126 /* Awake main task */
2127 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2128
2129 /* Init confirm counter */
2130 peer->confirm = 0;
2131
2132 /* Init cursors */
2133 for (st = peer->tables; st ; st = st->next) {
2134 st->last_get = st->last_acked = 0;
2135 st->teaching_origin = st->last_pushed = st->update;
2136 }
2137
2138 /* reset teaching and learning flags to 0 */
2139 peer->flags &= PEER_TEACH_RESET;
2140 peer->flags &= PEER_LEARN_RESET;
2141
2142 /* if current peer is local */
2143 if (peer->local) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002144 /* if current host need resyncfrom local and no process assigned */
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002145 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2146 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2147 /* assign local peer for a lesson, consider lesson already requested */
2148 peer->flags |= PEER_F_LEARN_ASSIGN;
2149 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2150 }
2151
2152 }
2153 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2154 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2155 /* assign peer for a lesson */
2156 peer->flags |= PEER_F_LEARN_ASSIGN;
2157 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2158 }
2159}
2160
2161/*
2162 * Init <peer> peer after having connected it at peer protocol level.
2163 */
2164static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2165{
2166 struct shared_table *st;
2167
2168 /* Init cursors */
2169 for (st = peer->tables; st ; st = st->next) {
2170 st->last_get = st->last_acked = 0;
2171 st->teaching_origin = st->last_pushed = st->update;
2172 }
2173
2174 /* Init confirm counter */
2175 peer->confirm = 0;
2176
2177 /* reset teaching and learning flags to 0 */
2178 peer->flags &= PEER_TEACH_RESET;
2179 peer->flags &= PEER_LEARN_RESET;
2180
2181 /* If current peer is local */
2182 if (peer->local) {
2183 /* flag to start to teach lesson */
2184 peer->flags |= PEER_F_TEACH_PROCESS;
2185 }
2186 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2187 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2188 /* If peer is remote and resync from remote is needed,
2189 and no peer currently assigned */
2190
2191 /* assign peer for a lesson */
2192 peer->flags |= PEER_F_LEARN_ASSIGN;
2193 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2194 }
2195}
2196
2197/*
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002198 * IO Handler to handle message exchange with a peer
Emeric Brun2b920a12010-09-23 18:30:22 +02002199 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002200static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002201{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002202 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002203 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002204 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002205 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002206 int reql = 0;
2207 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002208 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002209 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002210
Joseph Herlant82b2f542018-11-15 12:19:14 -08002211 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002212 if (si_ic(si)->buf.size == 0) {
2213 si_rx_room_blk(si);
2214 goto out;
2215 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002216
Emeric Brun2b920a12010-09-23 18:30:22 +02002217 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002218 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002219switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002220 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002221 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002222 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002223 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002224 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002225 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002226 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002227 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002228 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002229 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2230 if (reql <= 0) {
2231 if (!reql)
2232 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002233 goto switchstate;
2234 }
2235
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002236 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002237 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002238 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002239 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002240 reql = peer_getline_host(appctx);
2241 if (reql <= 0) {
2242 if (!reql)
2243 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002244 goto switchstate;
2245 }
2246
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002247 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002248 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002249 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002250 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002251 reql = peer_getline_last(appctx, &curpeer);
2252 if (reql <= 0) {
2253 if (!reql)
2254 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002255 goto switchstate;
2256 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002257
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002258 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002259 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002260 if (curpeer->local) {
2261 /* Local connection, reply a retry */
2262 appctx->st0 = PEER_SESS_ST_EXIT;
2263 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2264 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002265 }
Emeric Brun80527f52017-06-19 17:46:37 +02002266
2267 /* we're killing a connection, we must apply a random delay before
2268 * retrying otherwise the other end will do the same and we can loop
2269 * for a while.
2270 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002271 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002272 peer_session_forceshutdown(curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002273 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002274 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2275 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2276 curpeer->flags |= PEER_F_DWNGRD;
2277 }
2278 else {
2279 curpeer->flags &= ~PEER_F_DWNGRD;
2280 }
2281 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002282 curpeer->appctx = appctx;
2283 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002284 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002285 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002286 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002287 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002288 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002289 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002290 if (!curpeer) {
2291 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002292 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002293 if (curpeer->appctx != appctx) {
2294 appctx->st0 = PEER_SESS_ST_END;
2295 goto switchstate;
2296 }
2297 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002298
2299 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002300 if (repl <= 0) {
2301 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002302 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002303 goto switchstate;
2304 }
2305
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002306 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002307
Emeric Brun2b920a12010-09-23 18:30:22 +02002308 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002309 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002310 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002311 goto switchstate;
2312 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002313 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002314 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002315 if (!curpeer) {
2316 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002317 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002318 if (curpeer->appctx != appctx) {
2319 appctx->st0 = PEER_SESS_ST_END;
2320 goto switchstate;
2321 }
2322 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002323
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002324 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002325 if (repl <= 0) {
2326 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002327 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002328 goto switchstate;
2329 }
2330
2331 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002332 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002333 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002334 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002335 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002336 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002337 if (!curpeer) {
2338 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002339 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002340 if (curpeer->appctx != appctx) {
2341 appctx->st0 = PEER_SESS_ST_END;
2342 goto switchstate;
2343 }
2344 }
2345
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002346 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002347 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002348
Frédéric Lécaillece025572019-01-21 13:38:06 +01002349 reql = peer_getline(appctx);
2350 if (!reql)
2351 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002352
Frédéric Lécaillece025572019-01-21 13:38:06 +01002353 if (reql < 0)
2354 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002355
2356 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002357 curpeer->statuscode = atoi(trash.area);
Emeric Brun2b920a12010-09-23 18:30:22 +02002358
2359 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002360 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002361
2362 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002363 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002364 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002365 }
2366 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002367 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2368 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002369 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002370 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002371 goto switchstate;
2372 }
Olivier Houcharded879892019-03-08 18:53:43 +01002373 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002374 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002375 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002376 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002377 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002378 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002379 char *msg_cur = trash.area;
2380 char *msg_end = trash.area;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002381 unsigned char msg_head[7];
Emeric Brun2b920a12010-09-23 18:30:22 +02002382 int totl = 0;
2383
Willy Tarreau2d372c22018-11-05 17:12:27 +01002384 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002385 if (!curpeer) {
2386 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002387 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002388 if (curpeer->appctx != appctx) {
2389 appctx->st0 = PEER_SESS_ST_END;
2390 goto switchstate;
2391 }
2392 }
2393
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002394 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2395 if (reql <= 0) {
2396 if (reql == -1)
2397 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002398 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002399 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002400
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002401 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002402 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002403 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002404
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002405 curpeer->flags |= PEER_F_ALIVE;
2406
Emeric Brun2b920a12010-09-23 18:30:22 +02002407 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002408 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002409 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002410 goto switchstate;
2411
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002412send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002413 if (curpeer->flags & PEER_F_HEARTBEAT) {
2414 curpeer->flags &= ~PEER_F_HEARTBEAT;
2415 repl = peer_send_heartbeatmsg(appctx);
2416 if (repl <= 0) {
2417 if (repl == -1)
2418 goto out;
2419 goto switchstate;
2420 }
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002421 curpeer->tx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002422 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002423 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002424 repl = peer_send_msgs(appctx, curpeer);
2425 if (repl <= 0) {
2426 if (repl == -1)
2427 goto out;
2428 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002429 }
2430
Emeric Brun2b920a12010-09-23 18:30:22 +02002431 /* noting more to do */
2432 goto out;
2433 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002434 case PEER_SESS_ST_EXIT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002435 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002436 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002437 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002438 if (peer_send_status_errormsg(appctx) == -1)
2439 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002440 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002441 goto switchstate;
2442 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002443 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002444 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002445 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002446 if (peer_send_error_size_limitmsg(appctx) == -1)
2447 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002448 appctx->st0 = PEER_SESS_ST_END;
2449 goto switchstate;
2450 }
2451 case PEER_SESS_ST_ERRPROTO: {
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002452 if (curpeer)
2453 curpeer->proto_err++;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002454 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002455 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002456 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002457 if (peer_send_error_protomsg(appctx) == -1)
2458 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002459 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002460 prev_state = appctx->st0;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002461 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002462 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002463 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002464 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002465 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002466 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002467 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002468 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002469 curpeer = NULL;
2470 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002471 si_shutw(si);
2472 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002473 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002474 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002475 }
2476 }
2477 }
2478out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002479 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002480
2481 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002482 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002483 return;
2484}
2485
Willy Tarreau30576452015-04-13 13:50:30 +02002486static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002487 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002488 .name = "<PEER>", /* used for logging */
2489 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002490 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002491};
Emeric Brun2b920a12010-09-23 18:30:22 +02002492
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002493
Emeric Brun2b920a12010-09-23 18:30:22 +02002494/*
2495 * Use this function to force a close of a peer session
2496 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002497static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002498{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002499 struct appctx *appctx = peer->appctx;
2500
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002501 /* Note that the peer sessions which have just been created
2502 * (->st0 == PEER_SESS_ST_CONNECT) must not
2503 * be shutdown, if not, the TCP session will never be closed
2504 * and stay in CLOSE_WAIT state after having been closed by
2505 * the remote side.
2506 */
2507 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002508 return;
2509
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002510 if (appctx->applet != &peer_applet)
2511 return;
2512
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002513 __peer_session_deinit(peer);
2514
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002515 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002516 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002517}
2518
Willy Tarreau91d96282015-03-13 15:47:26 +01002519/* Pre-configures a peers frontend to accept incoming connections */
2520void peers_setup_frontend(struct proxy *fe)
2521{
2522 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002523 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreau91d96282015-03-13 15:47:26 +01002524 fe->maxconn = 0;
2525 fe->conn_retries = CONN_RETRIES;
2526 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002527 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002528 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002529 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002530 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002531}
2532
Emeric Brun2b920a12010-09-23 18:30:22 +02002533/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002534 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002535 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002536static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002537{
Willy Tarreau04b92862017-09-15 11:01:04 +02002538 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002539 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002540 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002541 struct stream *s;
Emeric Brun2b920a12010-09-23 18:30:22 +02002542
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002543 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002544 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Emeric Brunb3971ab2015-05-12 18:49:09 +02002545 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002546 s = NULL;
2547
Emeric Brun1138fd02017-06-19 12:38:55 +02002548 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002549 if (!appctx)
2550 goto out_close;
2551
2552 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002553 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002554
Willy Tarreau04b92862017-09-15 11:01:04 +02002555 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002556 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002557 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002558 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002559 }
2560
Willy Tarreau87787ac2017-08-28 16:22:54 +02002561 if ((s = stream_new(sess, &appctx->obj_type)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002562 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002563 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002564 }
2565
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002566 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002567 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002568 appctx_wakeup(appctx);
2569
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002570 /* initiate an outgoing connection */
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002571 s->target = peer_session_target(peer, s);
2572 if (!sockaddr_alloc(&s->target_addr))
2573 goto out_free_strm;
2574 *s->target_addr = peer->addr;
Willy Tarreau02efeda2019-07-18 17:21:24 +02002575 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Willy Tarreaudbd02672017-12-06 17:39:53 +01002576 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002577
Emeric Brun2b920a12010-09-23 18:30:22 +02002578 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002579 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002580
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002581 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002582
Emeric Brunb3971ab2015-05-12 18:49:09 +02002583 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002584 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002585 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002586 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002587
2588 /* Error unrolling */
Willy Tarreau15b5e142015-04-04 14:38:25 +02002589 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002590 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002591 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002592 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002593 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002594 out_free_appctx:
2595 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002596 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002597 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002598}
2599
2600/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002601 * Task processing function to manage re-connect, peer session
2602 * tasks wakeup on local update and heartbeat.
Emeric Brun2b920a12010-09-23 18:30:22 +02002603 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02002604static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002605{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002606 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002607 struct peer *ps;
2608 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002609
2610 task->expire = TICK_ETERNITY;
2611
Emeric Brunb3971ab2015-05-12 18:49:09 +02002612 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002613 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002614 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002615 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002616 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002617 return NULL;
2618 }
2619
Emeric Brun80527f52017-06-19 17:46:37 +02002620 /* Acquire lock for all peers of the section */
2621 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002622 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002623
Emeric Brun2b920a12010-09-23 18:30:22 +02002624 if (!stopping) {
2625 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002626
2627 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2628 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2629 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002630 /* Resync from local peer needed
2631 no peer was assigned for the lesson
2632 and no old local peer found
2633 or resync timeout expire */
2634
2635 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002636 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002637
2638 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002639 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002640 }
2641
2642 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002643 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002644 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002645 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002646 if (!ps->appctx) {
2647 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002648 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002649 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002650 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002651 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002652 tick_is_expired(ps->reconnect, now_ms))) {
2653 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002654 * or previous peer connection established with success
2655 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002656 * and reconnection timer is expired */
2657
2658 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002659 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002660 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002661 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002662 /* If previous session failed during connection
2663 * but reconnection timer is not expired */
2664
2665 /* reschedule task for reconnect */
2666 task->expire = tick_first(task->expire, ps->reconnect);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002667 ps->new_conn++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002668 }
2669 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002670 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002671 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002672 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002673 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2674 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002675 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2676 /* Resync from a remote is needed
2677 * and no peer was assigned for lesson
2678 * and current peer may be up2date */
2679
2680 /* assign peer for the lesson */
2681 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002682 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002683
Willy Tarreau9df94c22016-10-31 18:42:52 +01002684 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002685 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002686 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002687 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002688 int update_to_push = 0;
2689
Emeric Brunb3971ab2015-05-12 18:49:09 +02002690 /* Awake session if there is data to push */
2691 for (st = ps->tables; st ; st = st->next) {
2692 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002693 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002694 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002695 /* There is no need to send a heartbeat message
2696 * when some updates must be pushed. The remote
2697 * peer will consider <ps> peer as alive when it will
2698 * receive these updates.
2699 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002700 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002701 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002702 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002703 /* We are going to send updates, let's ensure we will
2704 * come back to send heartbeat messages or to reconnect.
2705 */
2706 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002707 appctx_wakeup(ps->appctx);
2708 break;
2709 }
2710 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002711 /* When there are updates to send we do not reconnect
2712 * and do not send heartbeat message either.
2713 */
2714 if (!update_to_push) {
2715 if (tick_is_expired(ps->reconnect, now_ms)) {
2716 if (ps->flags & PEER_F_ALIVE) {
2717 /* This peer was alive during a 'reconnect' period.
2718 * Flag it as not alive again for the next period.
2719 */
2720 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002721 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002722 }
2723 else {
Willy Tarreau52bf8392020-03-08 00:42:37 +01002724 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002725 peer_session_forceshutdown(ps);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002726 ps->no_hbt++;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002727 }
2728 }
2729 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2730 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
2731 ps->flags |= PEER_F_HEARTBEAT;
2732 appctx_wakeup(ps->appctx);
2733 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01002734 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002735 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002736 }
2737 /* else do nothing */
2738 } /* SUCCESSCODE */
2739 } /* !ps->peer->local */
2740 } /* for */
2741
2742 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002743 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2744 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2745 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002746 /* Resync from remote peer needed
2747 * no peer was assigned for the lesson
2748 * and resync timeout expire */
2749
2750 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002751 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002752 }
2753
Emeric Brunb3971ab2015-05-12 18:49:09 +02002754 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002755 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02002756 /* reschedule task to resync timeout if not expired, to ended resync if needed */
2757 if (!tick_is_expired(peers->resync_timeout, now_ms))
2758 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02002759 }
2760 } /* !stopping */
2761 else {
2762 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01002763 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08002764 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002765 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002766 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01002767 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002768 peers->flags |= PEERS_F_DONOTSTOP;
2769 ps = peers->local;
2770 for (st = ps->tables; st ; st = st->next)
2771 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002772 }
2773
2774 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002775 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02002776 /* we're killing a connection, we must apply a random delay before
2777 * retrying otherwise the other end will do the same and we can loop
2778 * for a while.
2779 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002780 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01002781 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002782 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002783 }
2784 }
2785 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002786
Emeric Brunb3971ab2015-05-12 18:49:09 +02002787 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02002788 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002789 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002790 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002791 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002792 peers->flags &= ~PEERS_F_DONOTSTOP;
2793 for (st = ps->tables; st ; st = st->next)
2794 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002795 }
2796 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01002797 else if (!ps->appctx) {
2798 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002799 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002800 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
2801 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
2802 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002803 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002804 * or previous peer connection was successfully established
2805 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02002806 * or during previous connect, peer replies a try again statuscode */
2807
2808 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002809 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002810 }
2811 else {
2812 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002813 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002814 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002815 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002816 peers->flags &= ~PEERS_F_DONOTSTOP;
2817 for (st = ps->tables; st ; st = st->next)
2818 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002819 }
2820 }
2821 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002822 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002823 /* current peer connection is active and established
2824 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002825 for (st = ps->tables; st ; st = st->next) {
2826 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002827 appctx_wakeup(ps->appctx);
2828 break;
2829 }
2830 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002831 }
2832 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02002833
2834 /* Release lock for all peers of the section */
2835 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002836 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002837
Emeric Brun2b920a12010-09-23 18:30:22 +02002838 /* Wakeup for re-connect */
2839 return task;
2840}
2841
Emeric Brunb3971ab2015-05-12 18:49:09 +02002842
Emeric Brun2b920a12010-09-23 18:30:22 +02002843/*
Willy Tarreaud9443442018-10-15 11:18:03 +02002844 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02002845 */
Willy Tarreaud9443442018-10-15 11:18:03 +02002846int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02002847{
Emeric Brun2b920a12010-09-23 18:30:22 +02002848 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02002849
Emeric Brun2b920a12010-09-23 18:30:22 +02002850 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002851 peers->peers_fe->maxconn += 3;
2852 }
2853
Emeric Brunc60def82017-09-27 14:59:38 +02002854 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02002855 if (!peers->sync_task)
2856 return 0;
2857
Emeric Brunb3971ab2015-05-12 18:49:09 +02002858 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002859 peers->sync_task->context = (void *)peers;
2860 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
2861 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02002862 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002863}
2864
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002865/*
2866 * Allocate a cache a dictionary entries used upon transmission.
2867 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002868static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002869{
2870 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002871 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002872
2873 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002874 entries = calloc(max_entries, sizeof *entries);
2875 if (!d || !entries)
2876 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002877
2878 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002879 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002880 d->cached_entries = EB_ROOT_UNIQUE;
2881 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002882
2883 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002884
2885 err:
2886 free(d);
2887 free(entries);
2888 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002889}
2890
2891/*
2892 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
2893 * as maximum of entries.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002894 * Return the dictionary cache if succeeded, NULL if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002895 * Must be deallocated calling free_dcache().
2896 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002897static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002898{
2899 struct dcache_tx *dc_tx;
2900 struct dcache *dc;
2901 struct dcache_rx *dc_rx;
2902
2903 dc = calloc(1, sizeof *dc);
2904 dc_tx = new_dcache_tx(max_entries);
2905 dc_rx = calloc(max_entries, sizeof *dc_rx);
2906 if (!dc || !dc_tx || !dc_rx)
2907 goto err;
2908
2909 dc->tx = dc_tx;
2910 dc->rx = dc_rx;
2911 dc->max_entries = max_entries;
2912
2913 return dc;
2914
2915 err:
2916 free(dc);
2917 free(dc_tx);
2918 free(dc_rx);
2919 return NULL;
2920}
2921
2922/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002923 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
2924 * entries used upon transmission.
2925 * Return the entry if found, NULL if not.
2926 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002927static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
2928 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002929{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002930 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002931}
2932
2933/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002934 * Flush <dc> cache.
2935 * Always succeeds.
2936 */
2937static inline void flush_dcache(struct peer *peer)
2938{
2939 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002940 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002941
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002942 for (i = 0; i < dc->max_entries; i++)
2943 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002944
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002945 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002946}
2947
2948/*
2949 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
2950 * with information provided by <i> dictionary cache entry (especially the value
2951 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002952 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002953 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002954static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002955{
2956 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002957 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002958
2959 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002960
2961 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
2962 o = dc_tx->prev_lookup;
2963 } else {
2964 o = dcache_tx_lookup_value(dc_tx, i);
2965 if (o) {
2966 /* Save it */
2967 dc_tx->prev_lookup = o;
2968 }
2969 }
2970
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002971 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002972 /* Copy the ID. */
2973 i->id = o - dc->tx->entries;
2974 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002975 }
2976
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002977 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002978 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002979
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002980 ebpt_delete(o);
2981 o->key = i->entry.key;
2982 ebpt_insert(&dc_tx->cached_entries, o);
2983 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002984
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002985 /* Update the index for the next entry to put in cache */
2986 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002987
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002988 return o;
2989}
Emeric Brunb3971ab2015-05-12 18:49:09 +02002990
2991/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002992 * Allocate a dictionary cache for each peer of <peers> section.
2993 * Return 1 if succeeded, 0 if not.
2994 */
2995int peers_alloc_dcache(struct peers *peers)
2996{
2997 struct peer *p;
2998
2999 for (p = peers->remote; p; p = p->next) {
3000 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
3001 if (!p->dcache)
3002 return 0;
3003 }
3004
3005 return 1;
3006}
3007
3008/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02003009 * Function used to register a table for sync on a group of peers
3010 *
3011 */
3012void peers_register_table(struct peers *peers, struct stktable *table)
3013{
3014 struct shared_table *st;
3015 struct peer * curpeer;
3016 int id = 0;
3017
3018 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003019 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003020 st->table = table;
3021 st->next = curpeer->tables;
3022 if (curpeer->tables)
3023 id = curpeer->tables->local_id;
3024 st->local_id = id + 1;
3025
3026 curpeer->tables = st;
3027 }
3028
3029 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003030}
3031
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003032/*
3033 * Parse the "show peers" command arguments.
3034 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3035 * error message.
3036 */
3037static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3038{
3039 appctx->ctx.cfgpeers.target = NULL;
3040
3041 if (*args[2]) {
3042 struct peers *p;
3043
3044 for (p = cfg_peers; p; p = p->next) {
3045 if (!strcmp(p->id, args[2])) {
3046 appctx->ctx.cfgpeers.target = p;
3047 break;
3048 }
3049 }
3050
Willy Tarreau9d008692019-08-09 11:21:01 +02003051 if (!p)
3052 return cli_err(appctx, "No such peers\n");
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003053 }
3054
3055 return 0;
3056}
3057
3058/*
3059 * This function dumps the peer state information of <peers> "peers" section.
3060 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3061 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3062 */
3063static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3064{
3065 struct tm tm;
3066
3067 get_localtime(peers->last_change, &tm);
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003068 chunk_appendf(msg, "%p: [%02d/%s/%04d:%02d:%02d:%02d] id=%s state=%d flags=0x%x resync_timeout=%s task_calls=%u\n",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003069 peers,
3070 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3071 tm.tm_hour, tm.tm_min, tm.tm_sec,
3072 peers->id, peers->state, peers->flags,
3073 peers->resync_timeout ?
3074 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3075 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003076 TICKS_TO_MS(1000)) : "<NEVER>",
3077 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003078
3079 if (ci_putchk(si_ic(si), msg) == -1) {
3080 si_rx_room_blk(si);
3081 return 0;
3082 }
3083
3084 return 1;
3085}
3086
3087/*
3088 * This function dumps <peer> state information.
3089 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3090 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3091 */
3092static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3093{
3094 struct connection *conn;
3095 char pn[INET6_ADDRSTRLEN];
3096 struct stream_interface *peer_si;
3097 struct stream *peer_s;
3098 struct appctx *appctx;
3099 struct shared_table *st;
3100
3101 addr_to_str(&peer->addr, pn, sizeof pn);
Frédéric Lécaillee7e2b212020-10-05 12:33:07 +02003102 chunk_appendf(msg, " %p: id=%s(%s,%s) addr=%s:%d last_status=%s reconnect=%s confirm=%u tx_hbt=%u rx_hbt=%u no_hbt=%u new_conn=%u proto_err=%u\n",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003103 peer, peer->id,
3104 peer->local ? "local" : "remote",
Frédéric Lécaillee7e2b212020-10-05 12:33:07 +02003105 peer->appctx ? "active" : "inactive",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003106 pn, get_host_port(&peer->addr),
3107 statuscode_str(peer->statuscode),
3108 peer->reconnect ?
3109 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3110 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
3111 TICKS_TO_MS(1000)) : "<NEVER>",
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003112 peer->confirm, peer->tx_hbt, peer->rx_hbt,
3113 peer->no_hbt, peer->new_conn, peer->proto_err);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003114
3115 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3116
3117 appctx = peer->appctx;
3118 if (!appctx)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003119 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003120
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003121 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3122 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003123
3124 peer_si = peer->appctx->owner;
3125 if (!peer_si)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003126 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003127
3128 peer_s = si_strm(peer_si);
3129 if (!peer_s)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003130 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003131
3132 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3133
3134 conn = objt_conn(strm_orig(peer_s));
3135 if (conn)
3136 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3137
Willy Tarreau3ca14902019-07-17 14:53:15 +02003138 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 +02003139 case AF_INET:
3140 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003141 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(conn->src));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003142 break;
3143 case AF_UNIX:
3144 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3145 break;
3146 }
3147
Willy Tarreau3ca14902019-07-17 14:53:15 +02003148 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 +02003149 case AF_INET:
3150 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003151 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(conn->dst));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003152 break;
3153 case AF_UNIX:
3154 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3155 break;
3156 }
3157
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003158 table_info:
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003159 if (peer->remote_table)
3160 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3161 peer->remote_table,
3162 peer->remote_table->table->id,
3163 peer->remote_table->local_id,
3164 peer->remote_table->remote_id);
3165
3166 if (peer->last_local_table)
3167 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3168 peer->last_local_table,
3169 peer->last_local_table->table->id,
3170 peer->last_local_table->local_id,
3171 peer->last_local_table->remote_id);
3172
3173 if (peer->tables) {
3174 chunk_appendf(&trash, "\n shared tables:");
3175 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003176 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003177 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003178 struct dcache *dcache;
3179
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003180 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003181 dcache = peer->dcache;
3182
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003183 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3184 "flags=0x%x remote_data=0x%llx",
3185 st, st->local_id, st->remote_id,
3186 st->flags, (unsigned long long)st->remote_data);
3187 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3188 " teaching_origin=%u update=%u",
3189 st->last_acked, st->last_pushed, st->last_get,
3190 st->teaching_origin, st->update);
3191 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3192 " commitupdate=%u syncing=%u",
3193 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003194 chunk_appendf(&trash, "\n TX dictionary cache:");
3195 count = 0;
3196 for (i = 0; i < dcache->max_entries; i++) {
3197 struct ebpt_node *node;
3198 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003199
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003200 node = &dcache->tx->entries[i];
3201 if (!node->key)
3202 break;
3203
3204 if (!count++)
3205 chunk_appendf(&trash, "\n ");
3206 de = node->key;
3207 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3208 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003209 }
3210 chunk_appendf(&trash, "\n RX dictionary cache:");
3211 count = 0;
3212 for (i = 0; i < dcache->max_entries; i++) {
3213 if (!count++)
3214 chunk_appendf(&trash, "\n ");
3215 chunk_appendf(&trash, " %3u -> %s", i,
3216 dcache->rx[i].de ?
3217 (char *)dcache->rx[i].de->value.key : "-");
3218 count &= 0x3;
3219 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003220 }
3221 }
3222
3223 end:
3224 chunk_appendf(&trash, "\n");
3225 if (ci_putchk(si_ic(si), msg) == -1) {
3226 si_rx_room_blk(si);
3227 return 0;
3228 }
3229
3230 return 1;
3231}
3232
3233/*
3234 * This function dumps all the peers of "peers" section.
3235 * Returns 0 if the output buffer is full and needs to be called
3236 * again, non-zero if not. It proceeds in an isolated thread, so
3237 * there is no thread safety issue here.
3238 */
3239static int cli_io_handler_show_peers(struct appctx *appctx)
3240{
3241 int show_all;
3242 int ret = 0, first_peers = 1;
3243 struct stream_interface *si = appctx->owner;
3244
3245 thread_isolate();
3246
3247 show_all = !appctx->ctx.cfgpeers.target;
3248
3249 chunk_reset(&trash);
3250
3251 while (appctx->st2 != STAT_ST_FIN) {
3252 switch (appctx->st2) {
3253 case STAT_ST_INIT:
3254 if (show_all)
3255 appctx->ctx.cfgpeers.peers = cfg_peers;
3256 else
3257 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3258
3259 appctx->st2 = STAT_ST_LIST;
3260 /* fall through */
3261
3262 case STAT_ST_LIST:
3263 if (!appctx->ctx.cfgpeers.peers) {
3264 /* No more peers list. */
3265 appctx->st2 = STAT_ST_END;
3266 }
3267 else {
3268 if (!first_peers)
3269 chunk_appendf(&trash, "\n");
3270 else
3271 first_peers = 0;
3272 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3273 goto out;
3274
3275 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3276 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3277 appctx->st2 = STAT_ST_INFO;
3278 }
3279 break;
3280
3281 case STAT_ST_INFO:
3282 if (!appctx->ctx.cfgpeers.peer) {
3283 /* End of peer list */
3284 if (show_all)
3285 appctx->st2 = STAT_ST_LIST;
3286 else
3287 appctx->st2 = STAT_ST_END;
3288 }
3289 else {
3290 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3291 goto out;
3292
3293 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3294 }
3295 break;
3296
3297 case STAT_ST_END:
3298 appctx->st2 = STAT_ST_FIN;
3299 break;
3300 }
3301 }
3302 ret = 1;
3303 out:
3304 thread_release();
3305 return ret;
3306}
3307
3308/*
3309 * CLI keywords.
3310 */
3311static struct cli_kw_list cli_kws = {{ }, {
3312 { { "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, },
3313 {},
3314}};
3315
3316/* Register cli keywords */
3317INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3318