blob: f16ba8e7e7b7b9ee8fe5468cc595c75e253fdd1a [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 = {
998 .updt.stksess = ts,
999 .updt.shared_table = st,
1000 .updt.updateid = updateid,
1001 .updt.use_identifier = use_identifier,
1002 .updt.use_timed = use_timed,
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001003 .updt.peer = appctx->ctx.peers.ptr,
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001004 };
1005
1006 return peer_send_msg(appctx, peer_prepare_updatemsg, &p);
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001007}
1008
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001009/*
1010 * Build a peer protocol control class message.
1011 * Returns the number of written bytes used to build the message if succeeded,
1012 * 0 if not.
1013 */
1014static int peer_prepare_control_msg(char *msg, size_t size, struct peer_prep_params *p)
1015{
1016 if (size < sizeof p->control.head)
1017 return 0;
1018
1019 msg[0] = p->control.head[0];
1020 msg[1] = p->control.head[1];
1021
1022 return 2;
1023}
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001024
1025/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001026 * Send a stick-table synchronization request message.
1027 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1028 * Returns -1 if there was not enough room left to send the message,
1029 * any other negative returned value must be considered as an error with an appctx st0
1030 * returned value equal to PEER_SESS_ST_END.
1031 */
1032static inline int peer_send_resync_reqmsg(struct appctx *appctx)
1033{
1034 struct peer_prep_params p = {
1035 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCREQ, },
1036 };
1037
1038 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1039}
1040
1041/*
1042 * Send a stick-table synchronization confirmation message.
1043 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1044 * Returns -1 if there was not enough room left to send the message,
1045 * any other negative returned value must be considered as an error with an appctx st0
1046 * returned value equal to PEER_SESS_ST_END.
1047 */
1048static inline int peer_send_resync_confirmsg(struct appctx *appctx)
1049{
1050 struct peer_prep_params p = {
1051 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCCONFIRM, },
1052 };
1053
1054 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1055}
1056
1057/*
1058 * Send a stick-table synchronization finished message.
1059 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1060 * Returns -1 if there was not enough room left to send the message,
1061 * any other negative returned value must be considered as an error with an appctx st0
1062 * returned value equal to PEER_SESS_ST_END.
1063 */
Emeric Brun70de43b2020-03-16 10:51:01 +01001064static inline int peer_send_resync_finishedmsg(struct appctx *appctx, struct peers *peers)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001065{
1066 struct peer_prep_params p = {
1067 .control.head = { PEER_MSG_CLASS_CONTROL, },
1068 };
1069
Emeric Brun70de43b2020-03-16 10:51:01 +01001070 p.control.head[1] = (peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED ?
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001071 PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
1072
1073 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1074}
1075
1076/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001077 * Send a heartbeat message.
1078 * Return 0 if the message could not be built modifying the appctx st0 to PEER_SESS_ST_END value.
1079 * Returns -1 if there was not enough room left to send the message,
1080 * any other negative returned value must be considered as an error with an appctx st0
1081 * returned value equal to PEER_SESS_ST_END.
1082 */
1083static inline int peer_send_heartbeatmsg(struct appctx *appctx)
1084{
1085 struct peer_prep_params p = {
1086 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_HEARTBEAT, },
1087 };
1088
1089 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1090}
1091
1092/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001093 * Build a peer protocol error class message.
1094 * Returns the number of written bytes used to build the message if succeeded,
1095 * 0 if not.
1096 */
1097static int peer_prepare_error_msg(char *msg, size_t size, struct peer_prep_params *p)
1098{
1099 if (size < sizeof p->error.head)
1100 return 0;
1101
1102 msg[0] = p->error.head[0];
1103 msg[1] = p->error.head[1];
1104
1105 return 2;
1106}
1107
1108/*
1109 * Send a "size limit reached" error message.
1110 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1111 * Returns -1 if there was not enough room left to send the message,
1112 * any other negative returned value must be considered as an error with an appctx st0
1113 * returned value equal to PEER_SESS_ST_END.
1114 */
1115static inline int peer_send_error_size_limitmsg(struct appctx *appctx)
1116{
1117 struct peer_prep_params p = {
1118 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_SIZELIMIT, },
1119 };
1120
1121 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1122}
1123
1124/*
1125 * Send a "peer protocol" error message.
1126 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1127 * Returns -1 if there was not enough room left to send the message,
1128 * any other negative returned value must be considered as an error with an appctx st0
1129 * returned value equal to PEER_SESS_ST_END.
1130 */
1131static inline int peer_send_error_protomsg(struct appctx *appctx)
1132{
1133 struct peer_prep_params p = {
1134 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_PROTOCOL, },
1135 };
1136
1137 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1138}
1139
1140/*
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001141 * Function used to lookup for recent stick-table updates associated with
1142 * <st> shared stick-table when a lesson must be taught a peer (PEER_F_LEARN_ASSIGN flag set).
1143 */
1144static inline struct stksess *peer_teach_process_stksess_lookup(struct shared_table *st)
1145{
1146 struct eb32_node *eb;
1147
1148 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1149 if (!eb) {
1150 eb = eb32_first(&st->table->updates);
1151 if (!eb || ((int)(eb->key - st->last_pushed) <= 0)) {
1152 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1153 return NULL;
1154 }
1155 }
1156
1157 if ((int)(eb->key - st->table->localupdate) > 0) {
1158 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1159 return NULL;
1160 }
1161
1162 return eb32_entry(eb, struct stksess, upd);
1163}
1164
1165/*
1166 * Function used to lookup for recent stick-table updates associated with
1167 * <st> shared stick-table during teach state 1 step.
1168 */
1169static inline struct stksess *peer_teach_stage1_stksess_lookup(struct shared_table *st)
1170{
1171 struct eb32_node *eb;
1172
1173 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1174 if (!eb) {
1175 st->flags |= SHTABLE_F_TEACH_STAGE1;
1176 eb = eb32_first(&st->table->updates);
1177 if (eb)
1178 st->last_pushed = eb->key - 1;
1179 return NULL;
1180 }
1181
1182 return eb32_entry(eb, struct stksess, upd);
1183}
1184
1185/*
1186 * Function used to lookup for recent stick-table updates associated with
1187 * <st> shared stick-table during teach state 2 step.
1188 */
1189static inline struct stksess *peer_teach_stage2_stksess_lookup(struct shared_table *st)
1190{
1191 struct eb32_node *eb;
1192
1193 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1194 if (!eb || eb->key > st->teaching_origin) {
1195 st->flags |= SHTABLE_F_TEACH_STAGE2;
1196 return NULL;
1197 }
1198
1199 return eb32_entry(eb, struct stksess, upd);
1200}
1201
1202/*
1203 * Generic function to emit update messages for <st> stick-table when a lesson must
1204 * be taught to the peer <p>.
1205 * <locked> must be set to 1 if the shared table <st> is already locked when entering
1206 * this function, 0 if not.
1207 *
1208 * This function temporary unlock/lock <st> when it sends stick-table updates or
1209 * when decrementing its refcount in case of any error when it sends this updates.
1210 *
1211 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1212 * Returns -1 if there was not enough room left to send the message,
1213 * any other negative returned value must be considered as an error with an appcxt st0
1214 * returned value equal to PEER_SESS_ST_END.
1215 * If it returns 0 or -1, this function leave <st> locked if already locked when entering this function
1216 * unlocked if not already locked when entering this function.
1217 */
1218static inline int peer_send_teachmsgs(struct appctx *appctx, struct peer *p,
1219 struct stksess *(*peer_stksess_lookup)(struct shared_table *),
1220 struct shared_table *st, int locked)
1221{
1222 int ret, new_pushed, use_timed;
1223
1224 ret = 1;
1225 use_timed = 0;
1226 if (st != p->last_local_table) {
1227 ret = peer_send_switchmsg(st, appctx);
1228 if (ret <= 0)
1229 return ret;
1230
1231 p->last_local_table = st;
1232 }
1233
1234 if (peer_stksess_lookup != peer_teach_process_stksess_lookup)
1235 use_timed = !(p->flags & PEER_F_DWNGRD);
1236
1237 /* We force new pushed to 1 to force identifier in update message */
1238 new_pushed = 1;
1239
1240 if (!locked)
1241 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1242
1243 while (1) {
1244 struct stksess *ts;
1245 unsigned updateid;
1246
1247 /* push local updates */
1248 ts = peer_stksess_lookup(st);
1249 if (!ts)
1250 break;
1251
1252 updateid = ts->upd.key;
1253 ts->ref_cnt++;
1254 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1255
1256 ret = peer_send_updatemsg(st, appctx, ts, updateid, new_pushed, use_timed);
1257 if (ret <= 0) {
1258 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1259 ts->ref_cnt--;
1260 if (!locked)
1261 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1262 return ret;
1263 }
1264
1265 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1266 ts->ref_cnt--;
1267 st->last_pushed = updateid;
1268
1269 if (peer_stksess_lookup == peer_teach_process_stksess_lookup &&
1270 (int)(st->last_pushed - st->table->commitupdate) > 0)
1271 st->table->commitupdate = st->last_pushed;
1272
1273 /* identifier may not needed in next update message */
1274 new_pushed = 0;
1275 }
1276
1277 out:
1278 if (!locked)
1279 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1280 return 1;
1281}
1282
1283/*
1284 * Function to emit update messages for <st> stick-table when a lesson must
1285 * be taught to the peer <p> (PEER_F_LEARN_ASSIGN flag set).
1286 *
1287 * Note that <st> shared stick-table is locked when calling this function.
1288 *
1289 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1290 * Returns -1 if there was not enough room left to send the message,
1291 * any other negative returned value must be considered as an error with an appcxt st0
1292 * returned value equal to PEER_SESS_ST_END.
1293 */
1294static inline int peer_send_teach_process_msgs(struct appctx *appctx, struct peer *p,
1295 struct shared_table *st)
1296{
1297 return peer_send_teachmsgs(appctx, p, peer_teach_process_stksess_lookup, st, 1);
1298}
1299
1300/*
1301 * Function to emit update messages for <st> stick-table when a lesson must
1302 * be taught to the peer <p> during teach state 1 step.
1303 *
1304 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1305 * Returns -1 if there was not enough room left to send the message,
1306 * any other negative returned value must be considered as an error with an appcxt st0
1307 * returned value equal to PEER_SESS_ST_END.
1308 */
1309static inline int peer_send_teach_stage1_msgs(struct appctx *appctx, struct peer *p,
1310 struct shared_table *st)
1311{
1312 return peer_send_teachmsgs(appctx, p, peer_teach_stage1_stksess_lookup, st, 0);
1313}
1314
1315/*
1316 * Function to emit update messages for <st> stick-table when a lesson must
1317 * be taught to the peer <p> during teach state 1 step.
1318 *
1319 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1320 * Returns -1 if there was not enough room left to send the message,
1321 * any other negative returned value must be considered as an error with an appcxt st0
1322 * returned value equal to PEER_SESS_ST_END.
1323 */
1324static inline int peer_send_teach_stage2_msgs(struct appctx *appctx, struct peer *p,
1325 struct shared_table *st)
1326{
1327 return peer_send_teachmsgs(appctx, p, peer_teach_stage2_stksess_lookup, st, 0);
1328}
1329
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001330
1331/*
1332 * Function used to parse a stick-table update message after it has been received
1333 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1334 * receipt buffer with <msg_end> being position of the end of the stick-table message.
1335 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1336 * was encountered.
1337 * <exp> must be set if the stick-table entry expires.
1338 * <updt> must be set for PEER_MSG_STKT_UPDATE or PEER_MSG_STKT_UPDATE_TIMED stick-table
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001339 * 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 +01001340 * update ID.
1341 * <totl> is the length of the stick-table update message computed upon receipt.
1342 */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001343static int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int exp,
1344 char **msg_cur, char *msg_end, int msg_len, int totl)
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001345{
1346 struct stream_interface *si = appctx->owner;
1347 struct shared_table *st = p->remote_table;
1348 struct stksess *ts, *newts;
1349 uint32_t update;
1350 int expire;
1351 unsigned int data_type;
1352 void *data_ptr;
1353
1354 /* Here we have data message */
1355 if (!st)
1356 goto ignore_msg;
1357
1358 expire = MS_TO_TICKS(st->table->expire);
1359
1360 if (updt) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001361 if (msg_len < sizeof(update))
1362 goto malformed_exit;
1363
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001364 memcpy(&update, *msg_cur, sizeof(update));
1365 *msg_cur += sizeof(update);
1366 st->last_get = htonl(update);
1367 }
1368 else {
1369 st->last_get++;
1370 }
1371
1372 if (exp) {
1373 size_t expire_sz = sizeof expire;
1374
Willy Tarreau1e82a142019-01-29 11:08:06 +01001375 if (*msg_cur + expire_sz > msg_end)
1376 goto malformed_exit;
1377
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001378 memcpy(&expire, *msg_cur, expire_sz);
1379 *msg_cur += expire_sz;
1380 expire = ntohl(expire);
1381 }
1382
1383 newts = stksess_new(st->table, NULL);
1384 if (!newts)
1385 goto ignore_msg;
1386
1387 if (st->table->type == SMP_T_STR) {
1388 unsigned int to_read, to_store;
1389
1390 to_read = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001391 if (!*msg_cur)
1392 goto malformed_free_newts;
1393
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001394 to_store = MIN(to_read, st->table->key_size - 1);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001395 if (*msg_cur + to_store > msg_end)
1396 goto malformed_free_newts;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001397
1398 memcpy(newts->key.key, *msg_cur, to_store);
1399 newts->key.key[to_store] = 0;
1400 *msg_cur += to_read;
1401 }
1402 else if (st->table->type == SMP_T_SINT) {
1403 unsigned int netinteger;
1404
Willy Tarreau1e82a142019-01-29 11:08:06 +01001405 if (*msg_cur + sizeof(netinteger) > msg_end)
1406 goto malformed_free_newts;
1407
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001408 memcpy(&netinteger, *msg_cur, sizeof(netinteger));
1409 netinteger = ntohl(netinteger);
1410 memcpy(newts->key.key, &netinteger, sizeof(netinteger));
1411 *msg_cur += sizeof(netinteger);
1412 }
1413 else {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001414 if (*msg_cur + st->table->key_size > msg_end)
1415 goto malformed_free_newts;
1416
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001417 memcpy(newts->key.key, *msg_cur, st->table->key_size);
1418 *msg_cur += st->table->key_size;
1419 }
1420
1421 /* lookup for existing entry */
1422 ts = stktable_set_entry(st->table, newts);
1423 if (ts != newts) {
1424 stksess_free(st->table, newts);
1425 newts = NULL;
1426 }
1427
1428 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
1429
1430 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001431 uint64_t decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001432
1433 if (!((1 << data_type) & st->remote_data))
1434 continue;
1435
Willy Tarreau1e82a142019-01-29 11:08:06 +01001436 decoded_int = intdecode(msg_cur, msg_end);
1437 if (!*msg_cur)
1438 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001439
Willy Tarreau1e82a142019-01-29 11:08:06 +01001440 switch (stktable_data_types[data_type].std_type) {
1441 case STD_T_SINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001442 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1443 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001444 stktable_data_cast(data_ptr, std_t_sint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001445 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001446
Willy Tarreau1e82a142019-01-29 11:08:06 +01001447 case STD_T_UINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001448 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1449 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001450 stktable_data_cast(data_ptr, std_t_uint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001451 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001452
Willy Tarreau1e82a142019-01-29 11:08:06 +01001453 case STD_T_ULL:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001454 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1455 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001456 stktable_data_cast(data_ptr, std_t_ull) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001457 break;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001458
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001459 case STD_T_FRQP: {
1460 struct freq_ctr_period data;
1461
1462 /* First bit is reserved for the freq_ctr_period lock
1463 Note: here we're still protected by the stksess lock
1464 so we don't need to update the update the freq_ctr_period
1465 using its internal lock */
1466
Willy Tarreau1e82a142019-01-29 11:08:06 +01001467 data.curr_tick = tick_add(now_ms, -decoded_int) & ~0x1;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001468 data.curr_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001469 if (!*msg_cur)
1470 goto malformed_unlock;
1471
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001472 data.prev_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001473 if (!*msg_cur)
1474 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001475
1476 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1477 if (data_ptr)
1478 stktable_data_cast(data_ptr, std_t_frqp) = data;
1479 break;
1480 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001481 case STD_T_DICT: {
1482 struct buffer *chunk;
1483 size_t data_len, value_len;
1484 unsigned int id;
1485 struct dict_entry *de;
1486 struct dcache *dc;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001487 char *end;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001488
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +01001489 if (!decoded_int) {
1490 /* No entry. */
1491 break;
1492 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001493 data_len = decoded_int;
1494 if (*msg_cur + data_len > msg_end)
1495 goto malformed_unlock;
1496
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001497 /* Compute the end of the current data, <msg_end> being at the end of
1498 * the entire message.
1499 */
1500 end = *msg_cur + data_len;
1501 id = intdecode(msg_cur, end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001502 if (!*msg_cur || !id)
1503 goto malformed_unlock;
1504
1505 dc = p->dcache;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001506 if (*msg_cur == end) {
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001507 /* Dictionary entry key without value. */
1508 if (id > dc->max_entries)
1509 break;
1510 /* IDs sent over the network are numbered from 1. */
1511 de = dc->rx[id - 1].de;
1512 }
1513 else {
1514 chunk = get_trash_chunk();
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001515 value_len = intdecode(msg_cur, end);
1516 if (!*msg_cur || *msg_cur + value_len > end ||
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001517 unlikely(value_len + 1 >= chunk->size))
1518 goto malformed_unlock;
1519
1520 chunk_memcpy(chunk, *msg_cur, value_len);
1521 chunk->area[chunk->data] = '\0';
Frédéric Lécaille56aec0d2019-06-06 14:14:15 +02001522 *msg_cur += value_len;
1523
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001524 de = dict_insert(&server_name_dict, chunk->area);
1525 dc->rx[id - 1].de = de;
1526 }
1527 if (de) {
1528 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1529 if (data_ptr)
1530 stktable_data_cast(data_ptr, std_t_dict) = de;
1531 }
1532 break;
1533 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001534 }
1535 }
1536 /* Force new expiration */
1537 ts->expire = tick_add(now_ms, expire);
1538
1539 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1540 stktable_touch_remote(st->table, ts, 1);
1541 return 1;
1542
1543 ignore_msg:
1544 /* skip consumed message */
1545 co_skip(si_oc(si), totl);
1546 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001547
1548 malformed_unlock:
1549 /* malformed message */
1550 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1551 stktable_touch_remote(st->table, ts, 1);
1552 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1553 return 0;
1554
1555 malformed_free_newts:
1556 /* malformed message */
1557 stksess_free(st->table, newts);
1558 malformed_exit:
1559 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1560 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001561}
1562
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001563/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001564 * Function used to parse a stick-table update acknowledgement message after it
1565 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1566 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1567 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1568 * was encountered.
1569 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1570 */
1571static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1572 char **msg_cur, char *msg_end)
1573{
1574 /* ack message */
1575 uint32_t table_id ;
1576 uint32_t update;
1577 struct shared_table *st;
1578
1579 table_id = intdecode(msg_cur, msg_end);
1580 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1581 /* malformed message */
1582 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1583 return 0;
1584 }
1585
1586 memcpy(&update, *msg_cur, sizeof(update));
1587 update = ntohl(update);
1588
1589 for (st = p->tables; st; st = st->next) {
1590 if (st->local_id == table_id) {
1591 st->update = update;
1592 break;
1593 }
1594 }
1595
1596 return 1;
1597}
1598
1599/*
1600 * Function used to parse a stick-table switch message after it has been received
1601 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1602 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1603 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1604 * was encountered.
1605 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1606 */
1607static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1608 char **msg_cur, char *msg_end)
1609{
1610 struct shared_table *st;
1611 int table_id;
1612
1613 table_id = intdecode(msg_cur, msg_end);
1614 if (!*msg_cur) {
1615 /* malformed message */
1616 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1617 return 0;
1618 }
1619
1620 p->remote_table = NULL;
1621 for (st = p->tables; st; st = st->next) {
1622 if (st->remote_id == table_id) {
1623 p->remote_table = st;
1624 break;
1625 }
1626 }
1627
1628 return 1;
1629}
1630
1631/*
1632 * Function used to parse a stick-table definition message after it has been received
1633 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1634 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1635 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1636 * was encountered.
1637 * <totl> is the length of the stick-table update message computed upon receipt.
1638 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1639 */
1640static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1641 char **msg_cur, char *msg_end, int totl)
1642{
1643 struct stream_interface *si = appctx->owner;
1644 int table_id_len;
1645 struct shared_table *st;
1646 int table_type;
1647 int table_keylen;
1648 int table_id;
1649 uint64_t table_data;
1650
1651 table_id = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001652 if (!*msg_cur)
1653 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001654
1655 table_id_len = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001656 if (!*msg_cur)
1657 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001658
1659 p->remote_table = NULL;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001660 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end)
1661 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001662
1663 for (st = p->tables; st; st = st->next) {
1664 /* Reset IDs */
1665 if (st->remote_id == table_id)
1666 st->remote_id = 0;
1667
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001668 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1669 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001670 p->remote_table = st;
1671 }
1672
1673 if (!p->remote_table)
1674 goto ignore_msg;
1675
1676 *msg_cur += table_id_len;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001677 if (*msg_cur >= msg_end)
1678 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001679
1680 table_type = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001681 if (!*msg_cur)
1682 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001683
1684 table_keylen = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001685 if (!*msg_cur)
1686 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001687
1688 table_data = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001689 if (!*msg_cur)
1690 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001691
Emeric Brun530ba382020-06-02 11:17:42 +02001692 if (p->remote_table->table->type != peer_int_key_type[table_type]
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001693 || p->remote_table->table->key_size != table_keylen) {
1694 p->remote_table = NULL;
1695 goto ignore_msg;
1696 }
1697
1698 p->remote_table->remote_data = table_data;
1699 p->remote_table->remote_id = table_id;
1700 return 1;
1701
1702 ignore_msg:
1703 co_skip(si_oc(si), totl);
1704 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001705
1706 malformed_exit:
1707 /* malformed message */
1708 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1709 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001710}
1711
1712/*
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001713 * Receive a stick-table message.
1714 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1715 * -1 if there was an error updating the appctx state st0 accordingly.
1716 */
1717static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1718 uint32_t *msg_len, int *totl)
1719{
1720 int reql;
1721 struct stream_interface *si = appctx->owner;
1722
1723 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1724 if (reql <= 0) /* closed or EOL not found */
1725 goto incomplete;
1726
1727 *totl += reql;
1728
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001729 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001730 return 1;
1731
1732 /* Read and Decode message length */
1733 reql = co_getblk(si_oc(si), &msg_head[2], sizeof(char), *totl);
1734 if (reql <= 0) /* closed */
1735 goto incomplete;
1736
1737 *totl += reql;
1738
Frédéric Lécaille32b55732019-06-03 18:29:51 +02001739 if ((unsigned int)msg_head[2] < PEER_ENC_2BYTES_MIN) {
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001740 *msg_len = msg_head[2];
1741 }
1742 else {
1743 int i;
1744 char *cur;
1745 char *end;
1746
1747 for (i = 3 ; i < msg_head_sz ; i++) {
1748 reql = co_getblk(si_oc(si), &msg_head[i], sizeof(char), *totl);
1749 if (reql <= 0) /* closed */
1750 goto incomplete;
1751
1752 *totl += reql;
1753
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001754 if (!(msg_head[i] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001755 break;
1756 }
1757
1758 if (i == msg_head_sz) {
1759 /* malformed message */
1760 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1761 return -1;
1762 }
1763 end = msg_head + msg_head_sz;
1764 cur = &msg_head[2];
1765 *msg_len = intdecode(&cur, end);
1766 if (!cur) {
1767 /* malformed message */
1768 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1769 return -1;
1770 }
1771 }
1772
1773 /* Read message content */
1774 if (*msg_len) {
1775 if (*msg_len > trash.size) {
1776 /* Status code is not success, abort */
1777 appctx->st0 = PEER_SESS_ST_ERRSIZE;
1778 return -1;
1779 }
1780
1781 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
1782 if (reql <= 0) /* closed */
1783 goto incomplete;
1784 *totl += reql;
1785 }
1786
1787 return 1;
1788
1789 incomplete:
1790 if (reql < 0) {
1791 /* there was an error */
1792 appctx->st0 = PEER_SESS_ST_END;
1793 return -1;
1794 }
1795
1796 return 0;
1797}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001798
1799/*
1800 * Treat the awaited message with <msg_head> as header.*
1801 * Return 1 if succeeded, 0 if not.
1802 */
1803static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
1804 char **msg_cur, char *msg_end, int msg_len, int totl)
1805{
1806 struct stream_interface *si = appctx->owner;
1807 struct stream *s = si_strm(si);
1808 struct peers *peers = strm_fe(s)->parent;
1809
1810 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
1811 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
1812 struct shared_table *st;
1813 /* Reset message: remote need resync */
1814
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001815 /* prepare tables for a global push */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001816 for (st = peer->tables; st; st = st->next) {
1817 st->teaching_origin = st->last_pushed = st->table->update;
1818 st->flags = 0;
1819 }
1820
1821 /* reset teaching flags to 0 */
1822 peer->flags &= PEER_TEACH_RESET;
1823
1824 /* flag to start to teach lesson */
1825 peer->flags |= PEER_F_TEACH_PROCESS;
1826 }
1827 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
1828 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1829 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1830 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1831 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
1832 }
1833 peer->confirm++;
1834 }
1835 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
1836 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1837 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1838 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1839
1840 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001841 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001842 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
1843 }
1844 peer->confirm++;
1845 }
1846 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
1847 struct shared_table *st;
1848
1849 /* If stopping state */
1850 if (stopping) {
1851 /* Close session, push resync no more needed */
1852 peer->flags |= PEER_F_TEACH_COMPLETE;
1853 appctx->st0 = PEER_SESS_ST_END;
1854 return 0;
1855 }
1856 for (st = peer->tables; st; st = st->next) {
1857 st->update = st->last_pushed = st->teaching_origin;
1858 st->flags = 0;
1859 }
1860
1861 /* reset teaching flags to 0 */
1862 peer->flags &= PEER_TEACH_RESET;
1863 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001864 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001865 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01001866 peer->rx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001867 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001868 }
1869 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
1870 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
1871 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
1872 return 0;
1873 }
1874 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
1875 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
1876 return 0;
1877 }
1878 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
1879 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
1880 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
1881 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
1882 int update, expire;
1883
1884 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
1885 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
1886 if (!peer_treat_updatemsg(appctx, peer, update, expire,
1887 msg_cur, msg_end, msg_len, totl))
1888 return 0;
1889
1890 }
1891 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
1892 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
1893 return 0;
1894 }
1895 }
1896 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
1897 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1898 return 0;
1899 }
1900
1901 return 1;
1902}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001903
1904
1905/*
1906 * Send any message to <peer> peer.
1907 * Returns 1 if succeeded, or -1 or 0 if failed.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001908 * -1 means an internal error occurred, 0 is for a peer protocol error leading
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001909 * to a peer state change (from the peer I/O handler point of view).
1910 */
1911static inline int peer_send_msgs(struct appctx *appctx, struct peer *peer)
1912{
1913 int repl;
1914 struct stream_interface *si = appctx->owner;
1915 struct stream *s = si_strm(si);
1916 struct peers *peers = strm_fe(s)->parent;
1917
1918 /* Need to request a resync */
1919 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
1920 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
1921 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
1922
1923 repl = peer_send_resync_reqmsg(appctx);
1924 if (repl <= 0)
1925 return repl;
1926
1927 peers->flags |= PEERS_F_RESYNC_PROCESS;
1928 }
1929
1930 /* Nothing to read, now we start to write */
1931 if (peer->tables) {
1932 struct shared_table *st;
1933 struct shared_table *last_local_table;
1934
1935 last_local_table = peer->last_local_table;
1936 if (!last_local_table)
1937 last_local_table = peer->tables;
1938 st = last_local_table->next;
1939
1940 while (1) {
1941 if (!st)
1942 st = peer->tables;
1943
1944 /* It remains some updates to ack */
1945 if (st->last_get != st->last_acked) {
1946 repl = peer_send_ackmsg(st, appctx);
1947 if (repl <= 0)
1948 return repl;
1949
1950 st->last_acked = st->last_get;
1951 }
1952
1953 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
1954 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1955 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
1956 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
1957
1958 repl = peer_send_teach_process_msgs(appctx, peer, st);
1959 if (repl <= 0) {
1960 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1961 return repl;
1962 }
1963 }
1964 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1965 }
1966 else {
1967 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
1968 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
1969 if (repl <= 0)
1970 return repl;
1971 }
1972
1973 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
1974 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
1975 if (repl <= 0)
1976 return repl;
1977 }
1978 }
1979
1980 if (st == last_local_table)
1981 break;
1982 st = st->next;
1983 }
1984 }
1985
1986 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
Emeric Brun70de43b2020-03-16 10:51:01 +01001987 repl = peer_send_resync_finishedmsg(appctx, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001988 if (repl <= 0)
1989 return repl;
1990
1991 /* flag finished message sent */
1992 peer->flags |= PEER_F_TEACH_FINISHED;
1993 }
1994
1995 /* Confirm finished or partial messages */
1996 while (peer->confirm) {
1997 repl = peer_send_resync_confirmsg(appctx);
1998 if (repl <= 0)
1999 return repl;
2000
2001 peer->confirm--;
2002 }
2003
2004 return 1;
2005}
2006
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002007/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002008 * Read and parse a first line of a "hello" peer protocol message.
2009 * Returns 0 if could not read a line, -1 if there was a read error or
2010 * the line is malformed, 1 if succeeded.
2011 */
2012static inline int peer_getline_version(struct appctx *appctx,
2013 unsigned int *maj_ver, unsigned int *min_ver)
2014{
2015 int reql;
2016
2017 reql = peer_getline(appctx);
2018 if (!reql)
2019 return 0;
2020
2021 if (reql < 0)
2022 return -1;
2023
2024 /* test protocol */
2025 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
2026 appctx->st0 = PEER_SESS_ST_EXIT;
2027 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2028 return -1;
2029 }
2030 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
2031 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
2032 appctx->st0 = PEER_SESS_ST_EXIT;
2033 appctx->st1 = PEER_SESS_SC_ERRVERSION;
2034 return -1;
2035 }
2036
2037 return 1;
2038}
2039
2040/*
2041 * Read and parse a second line of a "hello" peer protocol message.
2042 * Returns 0 if could not read a line, -1 if there was a read error or
2043 * the line is malformed, 1 if succeeded.
2044 */
2045static inline int peer_getline_host(struct appctx *appctx)
2046{
2047 int reql;
2048
2049 reql = peer_getline(appctx);
2050 if (!reql)
2051 return 0;
2052
2053 if (reql < 0)
2054 return -1;
2055
2056 /* test hostname match */
2057 if (strcmp(localpeer, trash.area) != 0) {
2058 appctx->st0 = PEER_SESS_ST_EXIT;
2059 appctx->st1 = PEER_SESS_SC_ERRHOST;
2060 return -1;
2061 }
2062
2063 return 1;
2064}
2065
2066/*
2067 * Read and parse a last line of a "hello" peer protocol message.
2068 * Returns 0 if could not read a character, -1 if there was a read error or
2069 * the line is malformed, 1 if succeeded.
2070 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2071 */
2072static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2073{
2074 char *p;
2075 int reql;
2076 struct peer *peer;
2077 struct stream_interface *si = appctx->owner;
2078 struct stream *s = si_strm(si);
2079 struct peers *peers = strm_fe(s)->parent;
2080
2081 reql = peer_getline(appctx);
2082 if (!reql)
2083 return 0;
2084
2085 if (reql < 0)
2086 return -1;
2087
2088 /* parse line "<peer name> <pid> <relative_pid>" */
2089 p = strchr(trash.area, ' ');
2090 if (!p) {
2091 appctx->st0 = PEER_SESS_ST_EXIT;
2092 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2093 return -1;
2094 }
2095 *p = 0;
2096
2097 /* lookup known peer */
2098 for (peer = peers->remote; peer; peer = peer->next) {
2099 if (strcmp(peer->id, trash.area) == 0)
2100 break;
2101 }
2102
2103 /* if unknown peer */
2104 if (!peer) {
2105 appctx->st0 = PEER_SESS_ST_EXIT;
2106 appctx->st1 = PEER_SESS_SC_ERRPEER;
2107 return -1;
2108 }
2109 *curpeer = peer;
2110
2111 return 1;
2112}
2113
2114/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002115 * Init <peer> peer after having accepted it at peer protocol level.
2116 */
2117static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2118{
2119 struct shared_table *st;
2120
2121 /* Register status code */
2122 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
2123
2124 /* Awake main task */
2125 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2126
2127 /* Init confirm counter */
2128 peer->confirm = 0;
2129
2130 /* Init cursors */
2131 for (st = peer->tables; st ; st = st->next) {
2132 st->last_get = st->last_acked = 0;
2133 st->teaching_origin = st->last_pushed = st->update;
2134 }
2135
2136 /* reset teaching and learning flags to 0 */
2137 peer->flags &= PEER_TEACH_RESET;
2138 peer->flags &= PEER_LEARN_RESET;
2139
2140 /* if current peer is local */
2141 if (peer->local) {
2142 /* if current host need resyncfrom local and no process assined */
2143 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2144 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2145 /* assign local peer for a lesson, consider lesson already requested */
2146 peer->flags |= PEER_F_LEARN_ASSIGN;
2147 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2148 }
2149
2150 }
2151 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2152 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2153 /* assign peer for a lesson */
2154 peer->flags |= PEER_F_LEARN_ASSIGN;
2155 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2156 }
2157}
2158
2159/*
2160 * Init <peer> peer after having connected it at peer protocol level.
2161 */
2162static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2163{
2164 struct shared_table *st;
2165
2166 /* Init cursors */
2167 for (st = peer->tables; st ; st = st->next) {
2168 st->last_get = st->last_acked = 0;
2169 st->teaching_origin = st->last_pushed = st->update;
2170 }
2171
2172 /* Init confirm counter */
2173 peer->confirm = 0;
2174
2175 /* reset teaching and learning flags to 0 */
2176 peer->flags &= PEER_TEACH_RESET;
2177 peer->flags &= PEER_LEARN_RESET;
2178
2179 /* If current peer is local */
2180 if (peer->local) {
2181 /* flag to start to teach lesson */
2182 peer->flags |= PEER_F_TEACH_PROCESS;
2183 }
2184 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2185 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2186 /* If peer is remote and resync from remote is needed,
2187 and no peer currently assigned */
2188
2189 /* assign peer for a lesson */
2190 peer->flags |= PEER_F_LEARN_ASSIGN;
2191 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2192 }
2193}
2194
2195/*
Emeric Brun2b920a12010-09-23 18:30:22 +02002196 * IO Handler to handle message exchance with a peer
2197 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002198static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002199{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002200 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002201 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002202 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002203 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002204 int reql = 0;
2205 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002206 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002207 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002208
Joseph Herlant82b2f542018-11-15 12:19:14 -08002209 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002210 if (si_ic(si)->buf.size == 0) {
2211 si_rx_room_blk(si);
2212 goto out;
2213 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002214
Emeric Brun2b920a12010-09-23 18:30:22 +02002215 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002216 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002217switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002218 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002219 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002220 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002221 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002222 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002223 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002224 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002225 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002226 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002227 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2228 if (reql <= 0) {
2229 if (!reql)
2230 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002231 goto switchstate;
2232 }
2233
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002234 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002235 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002236 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002237 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002238 reql = peer_getline_host(appctx);
2239 if (reql <= 0) {
2240 if (!reql)
2241 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002242 goto switchstate;
2243 }
2244
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002245 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002246 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002247 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002248 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002249 reql = peer_getline_last(appctx, &curpeer);
2250 if (reql <= 0) {
2251 if (!reql)
2252 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002253 goto switchstate;
2254 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002255
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002256 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002257 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002258 if (curpeer->local) {
2259 /* Local connection, reply a retry */
2260 appctx->st0 = PEER_SESS_ST_EXIT;
2261 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2262 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002263 }
Emeric Brun80527f52017-06-19 17:46:37 +02002264
2265 /* we're killing a connection, we must apply a random delay before
2266 * retrying otherwise the other end will do the same and we can loop
2267 * for a while.
2268 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002269 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002270 peer_session_forceshutdown(curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002271 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002272 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2273 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2274 curpeer->flags |= PEER_F_DWNGRD;
2275 }
2276 else {
2277 curpeer->flags &= ~PEER_F_DWNGRD;
2278 }
2279 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002280 curpeer->appctx = appctx;
2281 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002282 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002283 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002284 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002285 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002286 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002287 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002288 if (!curpeer) {
2289 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002290 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002291 if (curpeer->appctx != appctx) {
2292 appctx->st0 = PEER_SESS_ST_END;
2293 goto switchstate;
2294 }
2295 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002296
2297 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002298 if (repl <= 0) {
2299 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002300 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002301 goto switchstate;
2302 }
2303
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002304 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002305
Emeric Brun2b920a12010-09-23 18:30:22 +02002306 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002307 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002308 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002309 goto switchstate;
2310 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002311 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002312 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002313 if (!curpeer) {
2314 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002315 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002316 if (curpeer->appctx != appctx) {
2317 appctx->st0 = PEER_SESS_ST_END;
2318 goto switchstate;
2319 }
2320 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002321
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002322 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002323 if (repl <= 0) {
2324 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002325 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002326 goto switchstate;
2327 }
2328
2329 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002330 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002331 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002332 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002333 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002334 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002335 if (!curpeer) {
2336 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002337 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002338 if (curpeer->appctx != appctx) {
2339 appctx->st0 = PEER_SESS_ST_END;
2340 goto switchstate;
2341 }
2342 }
2343
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002344 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002345 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002346
Frédéric Lécaillece025572019-01-21 13:38:06 +01002347 reql = peer_getline(appctx);
2348 if (!reql)
2349 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002350
Frédéric Lécaillece025572019-01-21 13:38:06 +01002351 if (reql < 0)
2352 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002353
2354 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002355 curpeer->statuscode = atoi(trash.area);
Emeric Brun2b920a12010-09-23 18:30:22 +02002356
2357 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002358 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002359
2360 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002361 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002362 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002363 }
2364 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002365 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2366 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002367 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002368 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002369 goto switchstate;
2370 }
Olivier Houcharded879892019-03-08 18:53:43 +01002371 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002372 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002373 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002374 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002375 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002376 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002377 char *msg_cur = trash.area;
2378 char *msg_end = trash.area;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002379 unsigned char msg_head[7];
Emeric Brun2b920a12010-09-23 18:30:22 +02002380 int totl = 0;
2381
Willy Tarreau2d372c22018-11-05 17:12:27 +01002382 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002383 if (!curpeer) {
2384 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002385 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002386 if (curpeer->appctx != appctx) {
2387 appctx->st0 = PEER_SESS_ST_END;
2388 goto switchstate;
2389 }
2390 }
2391
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002392 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2393 if (reql <= 0) {
2394 if (reql == -1)
2395 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002396 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002397 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002398
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002399 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002400 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002401 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002402
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002403 curpeer->flags |= PEER_F_ALIVE;
2404
Emeric Brun2b920a12010-09-23 18:30:22 +02002405 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002406 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002407 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002408 goto switchstate;
2409
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002410send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002411 if (curpeer->flags & PEER_F_HEARTBEAT) {
2412 curpeer->flags &= ~PEER_F_HEARTBEAT;
2413 repl = peer_send_heartbeatmsg(appctx);
2414 if (repl <= 0) {
2415 if (repl == -1)
2416 goto out;
2417 goto switchstate;
2418 }
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002419 curpeer->tx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002420 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002421 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002422 repl = peer_send_msgs(appctx, curpeer);
2423 if (repl <= 0) {
2424 if (repl == -1)
2425 goto out;
2426 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002427 }
2428
Emeric Brun2b920a12010-09-23 18:30:22 +02002429 /* noting more to do */
2430 goto out;
2431 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002432 case PEER_SESS_ST_EXIT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002433 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002434 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002435 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002436 if (peer_send_status_errormsg(appctx) == -1)
2437 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002438 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002439 goto switchstate;
2440 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002441 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002442 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002443 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002444 if (peer_send_error_size_limitmsg(appctx) == -1)
2445 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002446 appctx->st0 = PEER_SESS_ST_END;
2447 goto switchstate;
2448 }
2449 case PEER_SESS_ST_ERRPROTO: {
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002450 if (curpeer)
2451 curpeer->proto_err++;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002452 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002453 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002454 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002455 if (peer_send_error_protomsg(appctx) == -1)
2456 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002457 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002458 prev_state = appctx->st0;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002459 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002460 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002461 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002462 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002463 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002464 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002465 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002466 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002467 curpeer = NULL;
2468 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002469 si_shutw(si);
2470 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002471 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002472 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002473 }
2474 }
2475 }
2476out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002477 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002478
2479 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002480 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002481 return;
2482}
2483
Willy Tarreau30576452015-04-13 13:50:30 +02002484static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002485 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002486 .name = "<PEER>", /* used for logging */
2487 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002488 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002489};
Emeric Brun2b920a12010-09-23 18:30:22 +02002490
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002491
Emeric Brun2b920a12010-09-23 18:30:22 +02002492/*
2493 * Use this function to force a close of a peer session
2494 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002495static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002496{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002497 struct appctx *appctx = peer->appctx;
2498
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002499 /* Note that the peer sessions which have just been created
2500 * (->st0 == PEER_SESS_ST_CONNECT) must not
2501 * be shutdown, if not, the TCP session will never be closed
2502 * and stay in CLOSE_WAIT state after having been closed by
2503 * the remote side.
2504 */
2505 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002506 return;
2507
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002508 if (appctx->applet != &peer_applet)
2509 return;
2510
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002511 __peer_session_deinit(peer);
2512
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002513 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002514 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002515}
2516
Willy Tarreau91d96282015-03-13 15:47:26 +01002517/* Pre-configures a peers frontend to accept incoming connections */
2518void peers_setup_frontend(struct proxy *fe)
2519{
2520 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002521 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreau91d96282015-03-13 15:47:26 +01002522 fe->maxconn = 0;
2523 fe->conn_retries = CONN_RETRIES;
2524 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002525 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002526 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002527 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002528 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002529}
2530
Emeric Brun2b920a12010-09-23 18:30:22 +02002531/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002532 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002533 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002534static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002535{
Willy Tarreau04b92862017-09-15 11:01:04 +02002536 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002537 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002538 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002539 struct stream *s;
Emeric Brun2b920a12010-09-23 18:30:22 +02002540
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002541 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002542 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Emeric Brunb3971ab2015-05-12 18:49:09 +02002543 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002544 s = NULL;
2545
Emeric Brun1138fd02017-06-19 12:38:55 +02002546 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002547 if (!appctx)
2548 goto out_close;
2549
2550 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002551 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002552
Willy Tarreau04b92862017-09-15 11:01:04 +02002553 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002554 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002555 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002556 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002557 }
2558
Willy Tarreau87787ac2017-08-28 16:22:54 +02002559 if ((s = stream_new(sess, &appctx->obj_type)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002560 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002561 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002562 }
2563
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002564 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002565 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002566 appctx_wakeup(appctx);
2567
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002568 /* initiate an outgoing connection */
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002569 s->target = peer_session_target(peer, s);
2570 if (!sockaddr_alloc(&s->target_addr))
2571 goto out_free_strm;
2572 *s->target_addr = peer->addr;
Willy Tarreau02efeda2019-07-18 17:21:24 +02002573 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Willy Tarreaudbd02672017-12-06 17:39:53 +01002574 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002575
Emeric Brun2b920a12010-09-23 18:30:22 +02002576 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002577 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002578
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002579 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002580
Emeric Brunb3971ab2015-05-12 18:49:09 +02002581 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002582 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002583 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002584 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002585
2586 /* Error unrolling */
Willy Tarreau15b5e142015-04-04 14:38:25 +02002587 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002588 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002589 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002590 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002591 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002592 out_free_appctx:
2593 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002594 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002595 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002596}
2597
2598/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002599 * Task processing function to manage re-connect, peer session
2600 * tasks wakeup on local update and heartbeat.
Emeric Brun2b920a12010-09-23 18:30:22 +02002601 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02002602static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002603{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002604 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002605 struct peer *ps;
2606 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002607
2608 task->expire = TICK_ETERNITY;
2609
Emeric Brunb3971ab2015-05-12 18:49:09 +02002610 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002611 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002612 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002613 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002614 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002615 return NULL;
2616 }
2617
Emeric Brun80527f52017-06-19 17:46:37 +02002618 /* Acquire lock for all peers of the section */
2619 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002620 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002621
Emeric Brun2b920a12010-09-23 18:30:22 +02002622 if (!stopping) {
2623 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002624
2625 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2626 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2627 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002628 /* Resync from local peer needed
2629 no peer was assigned for the lesson
2630 and no old local peer found
2631 or resync timeout expire */
2632
2633 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002634 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002635
2636 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002637 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002638 }
2639
2640 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002641 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002642 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002643 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002644 if (!ps->appctx) {
2645 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002646 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002647 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002648 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002649 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002650 tick_is_expired(ps->reconnect, now_ms))) {
2651 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002652 * or previous peer connection established with success
2653 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002654 * and reconnection timer is expired */
2655
2656 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002657 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002658 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002659 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002660 /* If previous session failed during connection
2661 * but reconnection timer is not expired */
2662
2663 /* reschedule task for reconnect */
2664 task->expire = tick_first(task->expire, ps->reconnect);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002665 ps->new_conn++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002666 }
2667 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002668 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002669 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002670 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002671 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2672 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002673 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2674 /* Resync from a remote is needed
2675 * and no peer was assigned for lesson
2676 * and current peer may be up2date */
2677
2678 /* assign peer for the lesson */
2679 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002680 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002681
Willy Tarreau9df94c22016-10-31 18:42:52 +01002682 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002683 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002684 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002685 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002686 int update_to_push = 0;
2687
Emeric Brunb3971ab2015-05-12 18:49:09 +02002688 /* Awake session if there is data to push */
2689 for (st = ps->tables; st ; st = st->next) {
2690 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002691 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002692 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002693 /* There is no need to send a heartbeat message
2694 * when some updates must be pushed. The remote
2695 * peer will consider <ps> peer as alive when it will
2696 * receive these updates.
2697 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002698 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002699 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002700 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002701 /* We are going to send updates, let's ensure we will
2702 * come back to send heartbeat messages or to reconnect.
2703 */
2704 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002705 appctx_wakeup(ps->appctx);
2706 break;
2707 }
2708 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002709 /* When there are updates to send we do not reconnect
2710 * and do not send heartbeat message either.
2711 */
2712 if (!update_to_push) {
2713 if (tick_is_expired(ps->reconnect, now_ms)) {
2714 if (ps->flags & PEER_F_ALIVE) {
2715 /* This peer was alive during a 'reconnect' period.
2716 * Flag it as not alive again for the next period.
2717 */
2718 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002719 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002720 }
2721 else {
Willy Tarreau52bf8392020-03-08 00:42:37 +01002722 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002723 peer_session_forceshutdown(ps);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002724 ps->no_hbt++;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002725 }
2726 }
2727 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2728 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
2729 ps->flags |= PEER_F_HEARTBEAT;
2730 appctx_wakeup(ps->appctx);
2731 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01002732 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002733 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002734 }
2735 /* else do nothing */
2736 } /* SUCCESSCODE */
2737 } /* !ps->peer->local */
2738 } /* for */
2739
2740 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002741 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2742 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2743 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002744 /* Resync from remote peer needed
2745 * no peer was assigned for the lesson
2746 * and resync timeout expire */
2747
2748 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002749 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002750 }
2751
Emeric Brunb3971ab2015-05-12 18:49:09 +02002752 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002753 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02002754 /* reschedule task to resync timeout if not expired, to ended resync if needed */
2755 if (!tick_is_expired(peers->resync_timeout, now_ms))
2756 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02002757 }
2758 } /* !stopping */
2759 else {
2760 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01002761 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08002762 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002763 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002764 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01002765 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002766 peers->flags |= PEERS_F_DONOTSTOP;
2767 ps = peers->local;
2768 for (st = ps->tables; st ; st = st->next)
2769 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002770 }
2771
2772 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002773 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02002774 /* we're killing a connection, we must apply a random delay before
2775 * retrying otherwise the other end will do the same and we can loop
2776 * for a while.
2777 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002778 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01002779 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002780 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002781 }
2782 }
2783 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002784
Emeric Brunb3971ab2015-05-12 18:49:09 +02002785 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02002786 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002787 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002788 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002789 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002790 peers->flags &= ~PEERS_F_DONOTSTOP;
2791 for (st = ps->tables; st ; st = st->next)
2792 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002793 }
2794 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01002795 else if (!ps->appctx) {
2796 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002797 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002798 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
2799 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
2800 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002801 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002802 * or previous peer connection was successfully established
2803 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02002804 * or during previous connect, peer replies a try again statuscode */
2805
2806 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002807 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002808 }
2809 else {
2810 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002811 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002812 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002813 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002814 peers->flags &= ~PEERS_F_DONOTSTOP;
2815 for (st = ps->tables; st ; st = st->next)
2816 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002817 }
2818 }
2819 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002820 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002821 /* current peer connection is active and established
2822 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002823 for (st = ps->tables; st ; st = st->next) {
2824 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002825 appctx_wakeup(ps->appctx);
2826 break;
2827 }
2828 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002829 }
2830 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02002831
2832 /* Release lock for all peers of the section */
2833 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002834 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002835
Emeric Brun2b920a12010-09-23 18:30:22 +02002836 /* Wakeup for re-connect */
2837 return task;
2838}
2839
Emeric Brunb3971ab2015-05-12 18:49:09 +02002840
Emeric Brun2b920a12010-09-23 18:30:22 +02002841/*
Willy Tarreaud9443442018-10-15 11:18:03 +02002842 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02002843 */
Willy Tarreaud9443442018-10-15 11:18:03 +02002844int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02002845{
Emeric Brun2b920a12010-09-23 18:30:22 +02002846 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02002847
Emeric Brun2b920a12010-09-23 18:30:22 +02002848 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002849 peers->peers_fe->maxconn += 3;
2850 }
2851
Emeric Brunc60def82017-09-27 14:59:38 +02002852 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02002853 if (!peers->sync_task)
2854 return 0;
2855
Emeric Brunb3971ab2015-05-12 18:49:09 +02002856 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002857 peers->sync_task->context = (void *)peers;
2858 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
2859 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02002860 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002861}
2862
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002863/*
2864 * Allocate a cache a dictionary entries used upon transmission.
2865 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002866static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002867{
2868 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002869 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002870
2871 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002872 entries = calloc(max_entries, sizeof *entries);
2873 if (!d || !entries)
2874 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002875
2876 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002877 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002878 d->cached_entries = EB_ROOT_UNIQUE;
2879 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002880
2881 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002882
2883 err:
2884 free(d);
2885 free(entries);
2886 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002887}
2888
2889/*
2890 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
2891 * as maximum of entries.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002892 * Return the dictionary cache if succeeded, NULL if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002893 * Must be deallocated calling free_dcache().
2894 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002895static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002896{
2897 struct dcache_tx *dc_tx;
2898 struct dcache *dc;
2899 struct dcache_rx *dc_rx;
2900
2901 dc = calloc(1, sizeof *dc);
2902 dc_tx = new_dcache_tx(max_entries);
2903 dc_rx = calloc(max_entries, sizeof *dc_rx);
2904 if (!dc || !dc_tx || !dc_rx)
2905 goto err;
2906
2907 dc->tx = dc_tx;
2908 dc->rx = dc_rx;
2909 dc->max_entries = max_entries;
2910
2911 return dc;
2912
2913 err:
2914 free(dc);
2915 free(dc_tx);
2916 free(dc_rx);
2917 return NULL;
2918}
2919
2920/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002921 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
2922 * entries used upon transmission.
2923 * Return the entry if found, NULL if not.
2924 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002925static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
2926 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002927{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002928 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002929}
2930
2931/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002932 * Flush <dc> cache.
2933 * Always succeeds.
2934 */
2935static inline void flush_dcache(struct peer *peer)
2936{
2937 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002938 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002939
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002940 for (i = 0; i < dc->max_entries; i++)
2941 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002942
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002943 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002944}
2945
2946/*
2947 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
2948 * with information provided by <i> dictionary cache entry (especially the value
2949 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002950 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002951 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002952static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002953{
2954 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002955 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002956
2957 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002958
2959 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
2960 o = dc_tx->prev_lookup;
2961 } else {
2962 o = dcache_tx_lookup_value(dc_tx, i);
2963 if (o) {
2964 /* Save it */
2965 dc_tx->prev_lookup = o;
2966 }
2967 }
2968
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002969 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002970 /* Copy the ID. */
2971 i->id = o - dc->tx->entries;
2972 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002973 }
2974
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002975 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002976 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002977
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002978 ebpt_delete(o);
2979 o->key = i->entry.key;
2980 ebpt_insert(&dc_tx->cached_entries, o);
2981 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002982
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002983 /* Update the index for the next entry to put in cache */
2984 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002985
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002986 return o;
2987}
Emeric Brunb3971ab2015-05-12 18:49:09 +02002988
2989/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002990 * Allocate a dictionary cache for each peer of <peers> section.
2991 * Return 1 if succeeded, 0 if not.
2992 */
2993int peers_alloc_dcache(struct peers *peers)
2994{
2995 struct peer *p;
2996
2997 for (p = peers->remote; p; p = p->next) {
2998 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
2999 if (!p->dcache)
3000 return 0;
3001 }
3002
3003 return 1;
3004}
3005
3006/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02003007 * Function used to register a table for sync on a group of peers
3008 *
3009 */
3010void peers_register_table(struct peers *peers, struct stktable *table)
3011{
3012 struct shared_table *st;
3013 struct peer * curpeer;
3014 int id = 0;
3015
3016 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003017 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003018 st->table = table;
3019 st->next = curpeer->tables;
3020 if (curpeer->tables)
3021 id = curpeer->tables->local_id;
3022 st->local_id = id + 1;
3023
3024 curpeer->tables = st;
3025 }
3026
3027 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003028}
3029
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003030/*
3031 * Parse the "show peers" command arguments.
3032 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3033 * error message.
3034 */
3035static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3036{
3037 appctx->ctx.cfgpeers.target = NULL;
3038
3039 if (*args[2]) {
3040 struct peers *p;
3041
3042 for (p = cfg_peers; p; p = p->next) {
3043 if (!strcmp(p->id, args[2])) {
3044 appctx->ctx.cfgpeers.target = p;
3045 break;
3046 }
3047 }
3048
Willy Tarreau9d008692019-08-09 11:21:01 +02003049 if (!p)
3050 return cli_err(appctx, "No such peers\n");
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003051 }
3052
3053 return 0;
3054}
3055
3056/*
3057 * This function dumps the peer state information of <peers> "peers" section.
3058 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3059 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3060 */
3061static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3062{
3063 struct tm tm;
3064
3065 get_localtime(peers->last_change, &tm);
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003066 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 +02003067 peers,
3068 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3069 tm.tm_hour, tm.tm_min, tm.tm_sec,
3070 peers->id, peers->state, peers->flags,
3071 peers->resync_timeout ?
3072 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3073 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003074 TICKS_TO_MS(1000)) : "<NEVER>",
3075 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003076
3077 if (ci_putchk(si_ic(si), msg) == -1) {
3078 si_rx_room_blk(si);
3079 return 0;
3080 }
3081
3082 return 1;
3083}
3084
3085/*
3086 * This function dumps <peer> state information.
3087 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3088 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3089 */
3090static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3091{
3092 struct connection *conn;
3093 char pn[INET6_ADDRSTRLEN];
3094 struct stream_interface *peer_si;
3095 struct stream *peer_s;
3096 struct appctx *appctx;
3097 struct shared_table *st;
3098
3099 addr_to_str(&peer->addr, pn, sizeof pn);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003100 chunk_appendf(msg, " %p: id=%s(%s) addr=%s:%d 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 +02003101 peer, peer->id,
3102 peer->local ? "local" : "remote",
3103 pn, get_host_port(&peer->addr),
3104 statuscode_str(peer->statuscode),
3105 peer->reconnect ?
3106 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3107 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
3108 TICKS_TO_MS(1000)) : "<NEVER>",
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003109 peer->confirm, peer->tx_hbt, peer->rx_hbt,
3110 peer->no_hbt, peer->new_conn, peer->proto_err);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003111
3112 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3113
3114 appctx = peer->appctx;
3115 if (!appctx)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003116 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003117
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003118 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3119 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003120
3121 peer_si = peer->appctx->owner;
3122 if (!peer_si)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003123 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003124
3125 peer_s = si_strm(peer_si);
3126 if (!peer_s)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003127 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003128
3129 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3130
3131 conn = objt_conn(strm_orig(peer_s));
3132 if (conn)
3133 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3134
Willy Tarreau3ca14902019-07-17 14:53:15 +02003135 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 +02003136 case AF_INET:
3137 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003138 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(conn->src));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003139 break;
3140 case AF_UNIX:
3141 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3142 break;
3143 }
3144
Willy Tarreau3ca14902019-07-17 14:53:15 +02003145 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 +02003146 case AF_INET:
3147 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003148 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(conn->dst));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003149 break;
3150 case AF_UNIX:
3151 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3152 break;
3153 }
3154
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003155 table_info:
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003156 if (peer->remote_table)
3157 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3158 peer->remote_table,
3159 peer->remote_table->table->id,
3160 peer->remote_table->local_id,
3161 peer->remote_table->remote_id);
3162
3163 if (peer->last_local_table)
3164 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3165 peer->last_local_table,
3166 peer->last_local_table->table->id,
3167 peer->last_local_table->local_id,
3168 peer->last_local_table->remote_id);
3169
3170 if (peer->tables) {
3171 chunk_appendf(&trash, "\n shared tables:");
3172 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003173 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003174 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003175 struct dcache *dcache;
3176
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003177 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003178 dcache = peer->dcache;
3179
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003180 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3181 "flags=0x%x remote_data=0x%llx",
3182 st, st->local_id, st->remote_id,
3183 st->flags, (unsigned long long)st->remote_data);
3184 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3185 " teaching_origin=%u update=%u",
3186 st->last_acked, st->last_pushed, st->last_get,
3187 st->teaching_origin, st->update);
3188 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3189 " commitupdate=%u syncing=%u",
3190 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003191 chunk_appendf(&trash, "\n TX dictionary cache:");
3192 count = 0;
3193 for (i = 0; i < dcache->max_entries; i++) {
3194 struct ebpt_node *node;
3195 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003196
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003197 node = &dcache->tx->entries[i];
3198 if (!node->key)
3199 break;
3200
3201 if (!count++)
3202 chunk_appendf(&trash, "\n ");
3203 de = node->key;
3204 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3205 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003206 }
3207 chunk_appendf(&trash, "\n RX dictionary cache:");
3208 count = 0;
3209 for (i = 0; i < dcache->max_entries; i++) {
3210 if (!count++)
3211 chunk_appendf(&trash, "\n ");
3212 chunk_appendf(&trash, " %3u -> %s", i,
3213 dcache->rx[i].de ?
3214 (char *)dcache->rx[i].de->value.key : "-");
3215 count &= 0x3;
3216 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003217 }
3218 }
3219
3220 end:
3221 chunk_appendf(&trash, "\n");
3222 if (ci_putchk(si_ic(si), msg) == -1) {
3223 si_rx_room_blk(si);
3224 return 0;
3225 }
3226
3227 return 1;
3228}
3229
3230/*
3231 * This function dumps all the peers of "peers" section.
3232 * Returns 0 if the output buffer is full and needs to be called
3233 * again, non-zero if not. It proceeds in an isolated thread, so
3234 * there is no thread safety issue here.
3235 */
3236static int cli_io_handler_show_peers(struct appctx *appctx)
3237{
3238 int show_all;
3239 int ret = 0, first_peers = 1;
3240 struct stream_interface *si = appctx->owner;
3241
3242 thread_isolate();
3243
3244 show_all = !appctx->ctx.cfgpeers.target;
3245
3246 chunk_reset(&trash);
3247
3248 while (appctx->st2 != STAT_ST_FIN) {
3249 switch (appctx->st2) {
3250 case STAT_ST_INIT:
3251 if (show_all)
3252 appctx->ctx.cfgpeers.peers = cfg_peers;
3253 else
3254 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3255
3256 appctx->st2 = STAT_ST_LIST;
3257 /* fall through */
3258
3259 case STAT_ST_LIST:
3260 if (!appctx->ctx.cfgpeers.peers) {
3261 /* No more peers list. */
3262 appctx->st2 = STAT_ST_END;
3263 }
3264 else {
3265 if (!first_peers)
3266 chunk_appendf(&trash, "\n");
3267 else
3268 first_peers = 0;
3269 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3270 goto out;
3271
3272 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3273 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3274 appctx->st2 = STAT_ST_INFO;
3275 }
3276 break;
3277
3278 case STAT_ST_INFO:
3279 if (!appctx->ctx.cfgpeers.peer) {
3280 /* End of peer list */
3281 if (show_all)
3282 appctx->st2 = STAT_ST_LIST;
3283 else
3284 appctx->st2 = STAT_ST_END;
3285 }
3286 else {
3287 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3288 goto out;
3289
3290 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3291 }
3292 break;
3293
3294 case STAT_ST_END:
3295 appctx->st2 = STAT_ST_FIN;
3296 break;
3297 }
3298 }
3299 ret = 1;
3300 out:
3301 thread_release();
3302 return ret;
3303}
3304
3305/*
3306 * CLI keywords.
3307 */
3308static struct cli_kw_list cli_kws = {{ }, {
3309 { { "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, },
3310 {},
3311}};
3312
3313/* Register cli keywords */
3314INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3315