blob: 9782ff3c1e95587215cbf7a9920c1a635fabc95f [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
23#include <common/compat.h>
24#include <common/config.h>
Willy Tarreau6cde5d82020-02-25 09:41:22 +010025#include <common/net_helper.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020026#include <common/time.h>
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +020027#include <common/standard.h>
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +020028#include <common/hathreads.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020029
30#include <types/global.h>
Willy Tarreau3fdb3662012-11-12 00:42:33 +010031#include <types/listener.h>
32#include <types/obj_type.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020033#include <types/peers.h>
Frédéric Lécaille95679dc2019-04-15 10:25:27 +020034#include <types/stats.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020035
36#include <proto/acl.h>
Willy Tarreau8a8d83b2015-04-13 13:24:54 +020037#include <proto/applet.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020038#include <proto/channel.h>
Frédéric Lécaille95679dc2019-04-15 10:25:27 +020039#include <proto/cli.h>
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +020040#include <proto/dict.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020041#include <proto/fd.h>
Willy Tarreaud1d48d42015-03-13 16:15:46 +010042#include <proto/frontend.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020043#include <proto/log.h>
Willy Tarreau53a47662017-08-28 10:53:00 +020044#include <proto/mux_pt.h>
Frédéric Lécaille1055e682018-04-26 14:35:21 +020045#include <proto/peers.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020046#include <proto/proxy.h>
Willy Tarreaufeb76402015-04-03 14:10:06 +020047#include <proto/session.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020048#include <proto/stream.h>
Willy Tarreau22ec1ea2014-11-27 20:45:39 +010049#include <proto/signal.h>
50#include <proto/stick_table.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020051#include <proto/stream_interface.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020052#include <proto/task.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020053
54
55/*******************************/
56/* Current peer learning state */
57/*******************************/
58
59/******************************/
Emeric Brunb3971ab2015-05-12 18:49:09 +020060/* Current peers section resync state */
Emeric Brun2b920a12010-09-23 18:30:22 +020061/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010062#define PEERS_F_RESYNC_LOCAL 0x00000001 /* Learn from local finished or no more needed */
63#define PEERS_F_RESYNC_REMOTE 0x00000002 /* Learn from remote finished or no more needed */
64#define PEERS_F_RESYNC_ASSIGN 0x00000004 /* A peer was assigned to learn our lesson */
65#define PEERS_F_RESYNC_PROCESS 0x00000008 /* The assigned peer was requested for resync */
66#define PEERS_F_DONOTSTOP 0x00010000 /* Main table sync task block process during soft stop
67 to push data to new process */
Emeric Brun2b920a12010-09-23 18:30:22 +020068
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010069#define PEERS_RESYNC_STATEMASK (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
70#define PEERS_RESYNC_FROMLOCAL 0x00000000
71#define PEERS_RESYNC_FROMREMOTE PEERS_F_RESYNC_LOCAL
72#define PEERS_RESYNC_FINISHED (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
Emeric Brunb3971ab2015-05-12 18:49:09 +020073
74/***********************************/
75/* Current shared table sync state */
76/***********************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010077#define SHTABLE_F_TEACH_STAGE1 0x00000001 /* Teach state 1 complete */
78#define SHTABLE_F_TEACH_STAGE2 0x00000002 /* Teach state 2 complete */
Emeric Brun2b920a12010-09-23 18:30:22 +020079
80/******************************/
81/* Remote peer teaching state */
82/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010083#define PEER_F_TEACH_PROCESS 0x00000001 /* Teach a lesson to current peer */
84#define PEER_F_TEACH_FINISHED 0x00000008 /* Teach conclude, (wait for confirm) */
85#define PEER_F_TEACH_COMPLETE 0x00000010 /* All that we know already taught to current peer, used only for a local peer */
86#define PEER_F_LEARN_ASSIGN 0x00000100 /* Current peer was assigned for a lesson */
87#define PEER_F_LEARN_NOTUP2DATE 0x00000200 /* Learn from peer finished but peer is not up to date */
88#define PEER_F_ALIVE 0x20000000 /* Used to flag a peer a alive. */
89#define PEER_F_HEARTBEAT 0x40000000 /* Heartbeat message to send. */
90#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 +020091
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010092#define PEER_TEACH_RESET ~(PEER_F_TEACH_PROCESS|PEER_F_TEACH_FINISHED) /* PEER_F_TEACH_COMPLETE should never be reset */
93#define PEER_LEARN_RESET ~(PEER_F_LEARN_ASSIGN|PEER_F_LEARN_NOTUP2DATE)
Emeric Brun2b920a12010-09-23 18:30:22 +020094
Frédéric Lécaille54bff832019-03-26 10:25:20 +010095#define PEER_RESYNC_TIMEOUT 5000 /* 5 seconds */
96#define PEER_RECONNECT_TIMEOUT 5000 /* 5 seconds */
Frédéric Lécaille645635d2019-02-11 17:49:39 +010097#define PEER_HEARTBEAT_TIMEOUT 3000 /* 3 seconds */
98
Emeric Brunb3971ab2015-05-12 18:49:09 +020099/*****************************/
100/* Sync message class */
101/*****************************/
102enum {
103 PEER_MSG_CLASS_CONTROL = 0,
104 PEER_MSG_CLASS_ERROR,
105 PEER_MSG_CLASS_STICKTABLE = 10,
106 PEER_MSG_CLASS_RESERVED = 255,
107};
108
109/*****************************/
110/* control message types */
111/*****************************/
112enum {
113 PEER_MSG_CTRL_RESYNCREQ = 0,
114 PEER_MSG_CTRL_RESYNCFINISHED,
115 PEER_MSG_CTRL_RESYNCPARTIAL,
116 PEER_MSG_CTRL_RESYNCCONFIRM,
Frédéric Lécaille645635d2019-02-11 17:49:39 +0100117 PEER_MSG_CTRL_HEARTBEAT,
Emeric Brunb3971ab2015-05-12 18:49:09 +0200118};
119
120/*****************************/
121/* error message types */
122/*****************************/
123enum {
124 PEER_MSG_ERR_PROTOCOL = 0,
125 PEER_MSG_ERR_SIZELIMIT,
126};
127
Emeric Brun530ba382020-06-02 11:17:42 +0200128/* network key types;
129 * network types were directly and mistakenly
130 * mapped on sample types, to keep backward
131 * compatiblitiy we keep those values but
132 * we now use a internal/network mapping
133 * to avoid further mistakes adding or
134 * modifying internals types
135 */
136enum {
137 PEER_KT_ANY = 0, /* any type */
138 PEER_KT_RESV1, /* UNUSED */
139 PEER_KT_SINT, /* signed 64bits integer type */
140 PEER_KT_RESV3, /* UNUSED */
141 PEER_KT_IPV4, /* ipv4 type */
142 PEER_KT_IPV6, /* ipv6 type */
143 PEER_KT_STR, /* char string type */
144 PEER_KT_BIN, /* buffer type */
145 PEER_KT_TYPES /* number of types, must always be last */
146};
147
148/* Map used to retrieve network type from internal type
149 * Note: Undeclared mapping maps entry to PEER_KT_ANY == 0
150 */
151static int peer_net_key_type[SMP_TYPES] = {
152 [SMP_T_SINT] = PEER_KT_SINT,
153 [SMP_T_IPV4] = PEER_KT_IPV4,
154 [SMP_T_IPV6] = PEER_KT_IPV6,
155 [SMP_T_STR] = PEER_KT_STR,
156 [SMP_T_BIN] = PEER_KT_BIN,
157};
158
159/* Map used to retrieve internal type from external type
160 * Note: Undeclared mapping maps entry to SMP_T_ANY == 0
161 */
162static int peer_int_key_type[PEER_KT_TYPES] = {
163 [PEER_KT_SINT] = SMP_T_SINT,
164 [PEER_KT_IPV4] = SMP_T_IPV4,
165 [PEER_KT_IPV6] = SMP_T_IPV6,
166 [PEER_KT_STR] = SMP_T_STR,
167 [PEER_KT_BIN] = SMP_T_BIN,
168};
169
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100170/*
171 * Parameters used by functions to build peer protocol messages. */
172struct peer_prep_params {
173 struct {
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100174 struct peer *peer;
175 } hello;
176 struct {
177 unsigned int st1;
178 } error_status;
179 struct {
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100180 struct stksess *stksess;
181 struct shared_table *shared_table;
182 unsigned int updateid;
183 int use_identifier;
184 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200185 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100186 } updt;
187 struct {
188 struct shared_table *shared_table;
189 } swtch;
190 struct {
191 struct shared_table *shared_table;
192 } ack;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100193 struct {
194 unsigned char head[2];
195 } control;
196 struct {
197 unsigned char head[2];
198 } error;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100199};
Emeric Brunb3971ab2015-05-12 18:49:09 +0200200
201/*******************************/
202/* stick table sync mesg types */
203/* Note: ids >= 128 contains */
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500204/* id message contains data */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200205/*******************************/
Olivier Houchard33992262018-10-16 18:49:26 +0200206#define PEER_MSG_STKT_UPDATE 0x80
207#define PEER_MSG_STKT_INCUPDATE 0x81
208#define PEER_MSG_STKT_DEFINE 0x82
209#define PEER_MSG_STKT_SWITCH 0x83
210#define PEER_MSG_STKT_ACK 0x84
211#define PEER_MSG_STKT_UPDATE_TIMED 0x85
212#define PEER_MSG_STKT_INCUPDATE_TIMED 0x86
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +0200213/* All the stick-table message identifiers abova have the #7 bit set */
214#define PEER_MSG_STKT_BIT 7
215#define PEER_MSG_STKT_BIT_MASK (1 << PEER_MSG_STKT_BIT)
Emeric Brun2b920a12010-09-23 18:30:22 +0200216
Frédéric Lécaille39143342019-05-24 14:32:27 +0200217/* The maximum length of an encoded data length. */
218#define PEER_MSG_ENC_LENGTH_MAXLEN 5
219
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200220/* Minimum 64-bits value encoded with 2 bytes */
221#define PEER_ENC_2BYTES_MIN 0xf0 /* 0xf0 (or 240) */
222/* 3 bytes */
223#define PEER_ENC_3BYTES_MIN ((1ULL << 11) | PEER_ENC_2BYTES_MIN) /* 0x8f0 (or 2288) */
224/* 4 bytes */
225#define PEER_ENC_4BYTES_MIN ((1ULL << 18) | PEER_ENC_3BYTES_MIN) /* 0x408f0 (or 264432) */
226/* 5 bytes */
227#define PEER_ENC_5BYTES_MIN ((1ULL << 25) | PEER_ENC_4BYTES_MIN) /* 0x20408f0 (or 33818864) */
228/* 6 bytes */
229#define PEER_ENC_6BYTES_MIN ((1ULL << 32) | PEER_ENC_5BYTES_MIN) /* 0x1020408f0 (or 4328786160) */
230/* 7 bytes */
231#define PEER_ENC_7BYTES_MIN ((1ULL << 39) | PEER_ENC_6BYTES_MIN) /* 0x81020408f0 (or 554084600048) */
232/* 8 bytes */
233#define PEER_ENC_8BYTES_MIN ((1ULL << 46) | PEER_ENC_7BYTES_MIN) /* 0x4081020408f0 (or 70922828777712) */
234/* 9 bytes */
235#define PEER_ENC_9BYTES_MIN ((1ULL << 53) | PEER_ENC_8BYTES_MIN) /* 0x204081020408f0 (or 9078122083518704) */
236/* 10 bytes */
237#define PEER_ENC_10BYTES_MIN ((1ULL << 60) | PEER_ENC_9BYTES_MIN) /* 0x10204081020408f0 (or 1161999626690365680) */
238
239/* #7 bit used to detect the last byte to be encoded */
240#define PEER_ENC_STOP_BIT 7
241/* The byte minimum value with #7 bit set */
242#define PEER_ENC_STOP_BYTE (1 << PEER_ENC_STOP_BIT)
243/* The left most number of bits set for PEER_ENC_2BYTES_MIN */
244#define PEER_ENC_2BYTES_MIN_BITS 4
245
Frédéric Lécaille39143342019-05-24 14:32:27 +0200246#define PEER_MSG_HEADER_LEN 2
247
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200248#define PEER_STKT_CACHE_MAX_ENTRIES 128
249
Emeric Brun2b920a12010-09-23 18:30:22 +0200250/**********************************/
251/* Peer Session IO handler states */
252/**********************************/
253
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100254enum {
255 PEER_SESS_ST_ACCEPT = 0, /* Initial state for session create by an accept, must be zero! */
256 PEER_SESS_ST_GETVERSION, /* Validate supported protocol version */
257 PEER_SESS_ST_GETHOST, /* Validate host ID correspond to local host id */
258 PEER_SESS_ST_GETPEER, /* Validate peer ID correspond to a known remote peer id */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100259 /* after this point, data were possibly exchanged */
260 PEER_SESS_ST_SENDSUCCESS, /* Send ret code 200 (success) and wait for message */
261 PEER_SESS_ST_CONNECT, /* Initial state for session create on a connect, push presentation into buffer */
262 PEER_SESS_ST_GETSTATUS, /* Wait for the welcome message */
263 PEER_SESS_ST_WAITMSG, /* Wait for data messages */
264 PEER_SESS_ST_EXIT, /* Exit with status code */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200265 PEER_SESS_ST_ERRPROTO, /* Send error proto message before exit */
266 PEER_SESS_ST_ERRSIZE, /* Send error size message before exit */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100267 PEER_SESS_ST_END, /* Killed session */
268};
Emeric Brun2b920a12010-09-23 18:30:22 +0200269
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100270/***************************************************/
271/* Peer Session status code - part of the protocol */
272/***************************************************/
Emeric Brun2b920a12010-09-23 18:30:22 +0200273
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100274#define PEER_SESS_SC_CONNECTCODE 100 /* connect in progress */
275#define PEER_SESS_SC_CONNECTEDCODE 110 /* tcp connect success */
Emeric Brun2b920a12010-09-23 18:30:22 +0200276
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100277#define PEER_SESS_SC_SUCCESSCODE 200 /* accept or connect successful */
Emeric Brun2b920a12010-09-23 18:30:22 +0200278
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100279#define PEER_SESS_SC_TRYAGAIN 300 /* try again later */
Emeric Brun2b920a12010-09-23 18:30:22 +0200280
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100281#define PEER_SESS_SC_ERRPROTO 501 /* error protocol */
282#define PEER_SESS_SC_ERRVERSION 502 /* unknown protocol version */
283#define PEER_SESS_SC_ERRHOST 503 /* bad host name */
284#define PEER_SESS_SC_ERRPEER 504 /* unknown peer */
Emeric Brun2b920a12010-09-23 18:30:22 +0200285
286#define PEER_SESSION_PROTO_NAME "HAProxyS"
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200287#define PEER_MAJOR_VER 2
288#define PEER_MINOR_VER 1
289#define PEER_DWNGRD_MINOR_VER 0
Emeric Brun2b920a12010-09-23 18:30:22 +0200290
Willy Tarreau6254a922019-01-29 17:45:23 +0100291static size_t proto_len = sizeof(PEER_SESSION_PROTO_NAME) - 1;
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200292struct peers *cfg_peers = NULL;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200293static void peer_session_forceshutdown(struct peer *peer);
Emeric Brun2b920a12010-09-23 18:30:22 +0200294
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200295static struct ebpt_node *dcache_tx_insert(struct dcache *dc,
296 struct dcache_tx_entry *i);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200297static inline void flush_dcache(struct peer *peer);
298
Frédéric Lécaille95679dc2019-04-15 10:25:27 +0200299static const char *statuscode_str(int statuscode)
300{
301 switch (statuscode) {
302 case PEER_SESS_SC_CONNECTCODE:
303 return "CONN";
304 case PEER_SESS_SC_CONNECTEDCODE:
305 return "HSHK";
306 case PEER_SESS_SC_SUCCESSCODE:
307 return "ESTA";
308 case PEER_SESS_SC_TRYAGAIN:
309 return "RETR";
310 case PEER_SESS_SC_ERRPROTO:
311 return "PROT";
312 case PEER_SESS_SC_ERRVERSION:
313 return "VERS";
314 case PEER_SESS_SC_ERRHOST:
315 return "NAME";
316 case PEER_SESS_SC_ERRPEER:
317 return "UNKN";
318 default:
319 return "NONE";
320 }
321}
322
Emeric Brun18928af2017-03-29 16:32:53 +0200323/* This function encode an uint64 to 'dynamic' length format.
324 The encoded value is written at address *str, and the
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500325 caller must assure that size after *str is large enough.
Emeric Brun18928af2017-03-29 16:32:53 +0200326 At return, the *str is set at the next Byte after then
327 encoded integer. The function returns then length of the
328 encoded integer in Bytes */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200329int intencode(uint64_t i, char **str) {
330 int idx = 0;
331 unsigned char *msg;
332
Emeric Brunb3971ab2015-05-12 18:49:09 +0200333 msg = (unsigned char *)*str;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200334 if (i < PEER_ENC_2BYTES_MIN) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200335 msg[0] = (unsigned char)i;
336 *str = (char *)&msg[idx+1];
337 return (idx+1);
338 }
339
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200340 msg[idx] =(unsigned char)i | PEER_ENC_2BYTES_MIN;
341 i = (i - PEER_ENC_2BYTES_MIN) >> PEER_ENC_2BYTES_MIN_BITS;
342 while (i >= PEER_ENC_STOP_BYTE) {
343 msg[++idx] = (unsigned char)i | PEER_ENC_STOP_BYTE;
344 i = (i - PEER_ENC_STOP_BYTE) >> PEER_ENC_STOP_BIT;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200345 }
346 msg[++idx] = (unsigned char)i;
347 *str = (char *)&msg[idx+1];
348 return (idx+1);
349}
350
351
352/* This function returns the decoded integer or 0
353 if decode failed
354 *str point on the beginning of the integer to decode
355 at the end of decoding *str point on the end of the
356 encoded integer or to null if end is reached */
Emeric Brun18928af2017-03-29 16:32:53 +0200357uint64_t intdecode(char **str, char *end)
358{
Emeric Brunb3971ab2015-05-12 18:49:09 +0200359 unsigned char *msg;
Emeric Brun18928af2017-03-29 16:32:53 +0200360 uint64_t i;
361 int shift;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200362
363 if (!*str)
364 return 0;
365
366 msg = (unsigned char *)*str;
Emeric Brun18928af2017-03-29 16:32:53 +0200367 if (msg >= (unsigned char *)end)
368 goto fail;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200369
Emeric Brun18928af2017-03-29 16:32:53 +0200370 i = *(msg++);
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200371 if (i >= PEER_ENC_2BYTES_MIN) {
372 shift = PEER_ENC_2BYTES_MIN_BITS;
Emeric Brun18928af2017-03-29 16:32:53 +0200373 do {
374 if (msg >= (unsigned char *)end)
375 goto fail;
376 i += (uint64_t)*msg << shift;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200377 shift += PEER_ENC_STOP_BIT;
378 } while (*(msg++) >= PEER_ENC_STOP_BYTE);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200379 }
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100380 *str = (char *)msg;
381 return i;
Emeric Brun18928af2017-03-29 16:32:53 +0200382
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100383 fail:
384 *str = NULL;
385 return 0;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200386}
Emeric Brun2b920a12010-09-23 18:30:22 +0200387
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100388/*
389 * Build a "hello" peer protocol message.
390 * Return the number of written bytes written to build this messages if succeeded,
391 * 0 if not.
392 */
393static int peer_prepare_hellomsg(char *msg, size_t size, struct peer_prep_params *p)
394{
395 int min_ver, ret;
396 struct peer *peer;
397
398 peer = p->hello.peer;
399 min_ver = (peer->flags & PEER_F_DWNGRD) ? PEER_DWNGRD_MINOR_VER : PEER_MINOR_VER;
400 /* Prepare headers */
401 ret = snprintf(msg, size, PEER_SESSION_PROTO_NAME " %u.%u\n%s\n%s %d %d\n",
402 PEER_MAJOR_VER, min_ver, peer->id, localpeer, (int)getpid(), relative_pid);
403 if (ret >= size)
404 return 0;
405
406 return ret;
407}
408
409/*
410 * Build a "handshake succeeded" status message.
411 * Return the number of written bytes written to build this messages if succeeded,
412 * 0 if not.
413 */
414static int peer_prepare_status_successmsg(char *msg, size_t size, struct peer_prep_params *p)
415{
416 int ret;
417
418 ret = snprintf(msg, size, "%d\n", PEER_SESS_SC_SUCCESSCODE);
419 if (ret >= size)
420 return 0;
421
422 return ret;
423}
424
425/*
426 * Build an error status message.
427 * Return the number of written bytes written to build this messages if succeeded,
428 * 0 if not.
429 */
430static int peer_prepare_status_errormsg(char *msg, size_t size, struct peer_prep_params *p)
431{
432 int ret;
433 unsigned int st1;
434
435 st1 = p->error_status.st1;
436 ret = snprintf(msg, size, "%d\n", st1);
437 if (ret >= size)
438 return 0;
439
440 return ret;
441}
442
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200443/* Set the stick-table UPDATE message type byte at <msg_type> address,
444 * depending on <use_identifier> and <use_timed> boolean parameters.
445 * Always successful.
446 */
447static inline void peer_set_update_msg_type(char *msg_type, int use_identifier, int use_timed)
448{
449 if (use_timed) {
450 if (use_identifier)
451 *msg_type = PEER_MSG_STKT_UPDATE_TIMED;
452 else
453 *msg_type = PEER_MSG_STKT_INCUPDATE_TIMED;
454 }
455 else {
456 if (use_identifier)
457 *msg_type = PEER_MSG_STKT_UPDATE;
458 else
459 *msg_type = PEER_MSG_STKT_INCUPDATE;
460 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200461}
Emeric Brun2b920a12010-09-23 18:30:22 +0200462/*
Emeric Brunb3971ab2015-05-12 18:49:09 +0200463 * This prepare the data update message on the stick session <ts>, <st> is the considered
464 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800465 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200466 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
467 * check size)
Emeric Brun2b920a12010-09-23 18:30:22 +0200468 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100469static int peer_prepare_updatemsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brun2b920a12010-09-23 18:30:22 +0200470{
471 uint32_t netinteger;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200472 unsigned short datalen;
473 char *cursor, *datamsg;
Emeric Brun94900952015-06-11 18:25:54 +0200474 unsigned int data_type;
475 void *data_ptr;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100476 struct stksess *ts;
477 struct shared_table *st;
478 unsigned int updateid;
479 int use_identifier;
480 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200481 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100482
483 ts = p->updt.stksess;
484 st = p->updt.shared_table;
485 updateid = p->updt.updateid;
486 use_identifier = p->updt.use_identifier;
487 use_timed = p->updt.use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200488 peer = p->updt.peer;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200489
Frédéric Lécaille0e8db972019-05-24 14:34:34 +0200490 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200491
Emeric Brun2b920a12010-09-23 18:30:22 +0200492 /* construct message */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200493
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500494 /* check if we need to send the update identifier */
Emeric Brun819fc6f2017-06-13 19:37:32 +0200495 if (!st->last_pushed || updateid < st->last_pushed || ((updateid - st->last_pushed) != 1)) {
Emeric Bruna6a09982015-09-22 15:34:19 +0200496 use_identifier = 1;
Emeric Brun2b920a12010-09-23 18:30:22 +0200497 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200498
499 /* encode update identifier if needed */
500 if (use_identifier) {
Emeric Brun819fc6f2017-06-13 19:37:32 +0200501 netinteger = htonl(updateid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200502 memcpy(cursor, &netinteger, sizeof(netinteger));
503 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200504 }
505
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200506 if (use_timed) {
507 netinteger = htonl(tick_remain(now_ms, ts->expire));
508 memcpy(cursor, &netinteger, sizeof(netinteger));
509 cursor += sizeof(netinteger);
510 }
511
Emeric Brunb3971ab2015-05-12 18:49:09 +0200512 /* encode the key */
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200513 if (st->table->type == SMP_T_STR) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200514 int stlen = strlen((char *)ts->key.key);
515
Emeric Brunb3971ab2015-05-12 18:49:09 +0200516 intencode(stlen, &cursor);
517 memcpy(cursor, ts->key.key, stlen);
518 cursor += stlen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200519 }
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200520 else if (st->table->type == SMP_T_SINT) {
Willy Tarreau6cde5d82020-02-25 09:41:22 +0100521 netinteger = htonl(read_u32(ts->key.key));
Emeric Brunb3971ab2015-05-12 18:49:09 +0200522 memcpy(cursor, &netinteger, sizeof(netinteger));
523 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200524 }
525 else {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200526 memcpy(cursor, ts->key.key, st->table->key_size);
527 cursor += st->table->key_size;
Emeric Brun2b920a12010-09-23 18:30:22 +0200528 }
529
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100530 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200531 /* encode values */
Emeric Brun94900952015-06-11 18:25:54 +0200532 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200533
Emeric Brun94900952015-06-11 18:25:54 +0200534 data_ptr = stktable_data_ptr(st->table, ts, data_type);
535 if (data_ptr) {
536 switch (stktable_data_types[data_type].std_type) {
537 case STD_T_SINT: {
538 int data;
539
540 data = stktable_data_cast(data_ptr, std_t_sint);
541 intencode(data, &cursor);
542 break;
543 }
544 case STD_T_UINT: {
545 unsigned int data;
546
547 data = stktable_data_cast(data_ptr, std_t_uint);
548 intencode(data, &cursor);
549 break;
550 }
551 case STD_T_ULL: {
552 unsigned long long data;
553
554 data = stktable_data_cast(data_ptr, std_t_ull);
555 intencode(data, &cursor);
556 break;
557 }
558 case STD_T_FRQP: {
559 struct freq_ctr_period *frqp;
560
561 frqp = &stktable_data_cast(data_ptr, std_t_frqp);
562 intencode((unsigned int)(now_ms - frqp->curr_tick), &cursor);
563 intencode(frqp->curr_ctr, &cursor);
564 intencode(frqp->prev_ctr, &cursor);
565 break;
566 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200567 case STD_T_DICT: {
568 struct dict_entry *de;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200569 struct ebpt_node *cached_de;
Willy Tarreau237f8ae2019-06-06 16:40:43 +0200570 struct dcache_tx_entry cde = { };
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200571 char *beg, *end;
572 size_t value_len, data_len;
573 struct dcache *dc;
574
575 de = stktable_data_cast(data_ptr, std_t_dict);
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100576 if (!de) {
577 /* No entry */
578 intencode(0, &cursor);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200579 break;
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100580 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200581
582 dc = peer->dcache;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200583 cde.entry.key = de;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200584 cached_de = dcache_tx_insert(dc, &cde);
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200585 if (cached_de == &cde.entry) {
586 if (cde.id + 1 >= PEER_ENC_2BYTES_MIN)
587 break;
588 /* Encode the length of the remaining data -> 1 */
589 intencode(1, &cursor);
590 /* Encode the cache entry ID */
591 intencode(cde.id + 1, &cursor);
592 }
593 else {
594 /* Leave enough room to encode the remaining data length. */
595 end = beg = cursor + PEER_MSG_ENC_LENGTH_MAXLEN;
596 /* Encode the dictionary entry key */
597 intencode(cde.id + 1, &end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200598 /* Encode the length of the dictionary entry data */
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200599 value_len = de->len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200600 intencode(value_len, &end);
601 /* Copy the data */
602 memcpy(end, de->value.key, value_len);
603 end += value_len;
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200604 /* Encode the length of the data */
605 data_len = end - beg;
606 intencode(data_len, &cursor);
607 memmove(cursor, beg, data_len);
608 cursor += data_len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200609 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200610 break;
611 }
Emeric Brun94900952015-06-11 18:25:54 +0200612 }
613 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200614 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100615 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200616
617 /* Compute datalen */
618 datalen = (cursor - datamsg);
619
620 /* prepare message header */
621 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200622 peer_set_update_msg_type(&msg[1], use_identifier, use_timed);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200623 cursor = &msg[2];
624 intencode(datalen, &cursor);
625
626 /* move data after header */
627 memmove(cursor, datamsg, datalen);
628
629 /* return header size + data_len */
630 return (cursor - msg) + datalen;
631}
632
633/*
634 * This prepare the switch table message to targeted share table <st>.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800635 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200636 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
637 * check size)
638 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100639static int peer_prepare_switchmsg(char *msg, size_t size, struct peer_prep_params *params)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200640{
641 int len;
642 unsigned short datalen;
Willy Tarreau83061a82018-07-13 11:56:34 +0200643 struct buffer *chunk;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200644 char *cursor, *datamsg, *chunkp, *chunkq;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200645 uint64_t data = 0;
Emeric Brun94900952015-06-11 18:25:54 +0200646 unsigned int data_type;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100647 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200648
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100649 st = params->swtch.shared_table;
Frédéric Lécaille39143342019-05-24 14:32:27 +0200650 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200651
652 /* Encode data */
653
654 /* encode local id */
655 intencode(st->local_id, &cursor);
656
657 /* encode table name */
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100658 len = strlen(st->table->nid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200659 intencode(len, &cursor);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100660 memcpy(cursor, st->table->nid, len);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200661 cursor += len;
662
663 /* encode table type */
664
Emeric Brun530ba382020-06-02 11:17:42 +0200665 intencode(peer_net_key_type[st->table->type], &cursor);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200666
667 /* encode table key size */
668 intencode(st->table->key_size, &cursor);
669
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200670 chunk = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200671 chunkp = chunkq = chunk->area;
Emeric Brun94900952015-06-11 18:25:54 +0200672 /* encode available known data types in table */
673 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
674 if (st->table->data_ofs[data_type]) {
675 switch (stktable_data_types[data_type].std_type) {
676 case STD_T_SINT:
677 case STD_T_UINT:
678 case STD_T_ULL:
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200679 case STD_T_DICT:
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200680 data |= 1 << data_type;
681 break;
Emeric Brun94900952015-06-11 18:25:54 +0200682 case STD_T_FRQP:
683 data |= 1 << data_type;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200684 intencode(data_type, &chunkq);
685 intencode(st->table->data_arg[data_type].u, &chunkq);
Emeric Brun94900952015-06-11 18:25:54 +0200686 break;
687 }
688 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200689 }
690 intencode(data, &cursor);
691
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200692 /* Encode stick-table entries duration. */
693 intencode(st->table->expire, &cursor);
694
695 if (chunkq > chunkp) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200696 chunk->data = chunkq - chunkp;
697 memcpy(cursor, chunk->area, chunk->data);
698 cursor += chunk->data;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200699 }
700
Emeric Brunb3971ab2015-05-12 18:49:09 +0200701 /* Compute datalen */
702 datalen = (cursor - datamsg);
Emeric Brun2b920a12010-09-23 18:30:22 +0200703
Emeric Brunb3971ab2015-05-12 18:49:09 +0200704 /* prepare message header */
705 msg[0] = PEER_MSG_CLASS_STICKTABLE;
706 msg[1] = PEER_MSG_STKT_DEFINE;
707 cursor = &msg[2];
708 intencode(datalen, &cursor);
Emeric Brun2b920a12010-09-23 18:30:22 +0200709
Emeric Brunb3971ab2015-05-12 18:49:09 +0200710 /* move data after header */
711 memmove(cursor, datamsg, datalen);
712
713 /* return header size + data_len */
714 return (cursor - msg) + datalen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200715}
716
Emeric Brunb3971ab2015-05-12 18:49:09 +0200717/*
718 * This prepare the acknowledge message on the stick session <ts>, <st> is the considered
719 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800720 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200721 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
722 * check size)
723 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100724static int peer_prepare_ackmsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200725{
726 unsigned short datalen;
727 char *cursor, *datamsg;
728 uint32_t netinteger;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100729 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200730
Frédéric Lécaille39143342019-05-24 14:32:27 +0200731 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200732
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100733 st = p->ack.shared_table;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200734 intencode(st->remote_id, &cursor);
735 netinteger = htonl(st->last_get);
736 memcpy(cursor, &netinteger, sizeof(netinteger));
737 cursor += sizeof(netinteger);
738
739 /* Compute datalen */
740 datalen = (cursor - datamsg);
741
742 /* prepare message header */
743 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Emeric Brune1ab8082015-08-21 11:48:54 +0200744 msg[1] = PEER_MSG_STKT_ACK;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200745 cursor = &msg[2];
746 intencode(datalen, &cursor);
747
748 /* move data after header */
749 memmove(cursor, datamsg, datalen);
750
751 /* return header size + data_len */
752 return (cursor - msg) + datalen;
753}
Emeric Brun2b920a12010-09-23 18:30:22 +0200754
755/*
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200756 * Function to deinit connected peer
757 */
758void __peer_session_deinit(struct peer *peer)
759{
760 struct stream_interface *si;
761 struct stream *s;
762 struct peers *peers;
763
764 if (!peer->appctx)
765 return;
766
767 si = peer->appctx->owner;
768 if (!si)
769 return;
770
771 s = si_strm(si);
772 if (!s)
773 return;
774
775 peers = strm_fe(s)->parent;
776 if (!peers)
777 return;
778
779 if (peer->appctx->st0 == PEER_SESS_ST_WAITMSG)
780 HA_ATOMIC_SUB(&connected_peers, 1);
781
782 HA_ATOMIC_SUB(&active_peers, 1);
783
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200784 flush_dcache(peer);
785
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200786 /* Re-init current table pointers to force announcement on re-connect */
787 peer->remote_table = peer->last_local_table = NULL;
788 peer->appctx = NULL;
789 if (peer->flags & PEER_F_LEARN_ASSIGN) {
790 /* unassign current peer for learning */
791 peer->flags &= ~(PEER_F_LEARN_ASSIGN);
792 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
793
794 /* reschedule a resync */
795 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
796 }
797 /* reset teaching and learning flags to 0 */
798 peer->flags &= PEER_TEACH_RESET;
799 peer->flags &= PEER_LEARN_RESET;
Frédéric Lécaille3585cab2019-11-20 11:17:30 +0100800 /* set this peer as dead from heartbeat point of view */
801 peer->flags &= ~PEER_F_ALIVE;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200802 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
803}
804
805/*
Emeric Brun2b920a12010-09-23 18:30:22 +0200806 * Callback to release a session with a peer
807 */
Willy Tarreau00a37f02015-04-13 12:05:19 +0200808static void peer_session_release(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +0200809{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200810 struct peer *peer = appctx->ctx.peers.ptr;
Emeric Brun2b920a12010-09-23 18:30:22 +0200811
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100812 /* appctx->ctx.peers.ptr is not a peer session */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100813 if (appctx->st0 < PEER_SESS_ST_SENDSUCCESS)
Emeric Brun2b920a12010-09-23 18:30:22 +0200814 return;
815
816 /* peer session identified */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200817 if (peer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100818 HA_SPIN_LOCK(PEER_LOCK, &peer->lock);
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200819 if (peer->appctx == appctx)
820 __peer_session_deinit(peer);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100821 HA_SPIN_UNLOCK(PEER_LOCK, &peer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +0200822 }
823}
824
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200825/* Retrieve the major and minor versions of peers protocol
826 * announced by a remote peer. <str> is a null-terminated
827 * string with the following format: "<maj_ver>.<min_ver>".
828 */
829static int peer_get_version(const char *str,
830 unsigned int *maj_ver, unsigned int *min_ver)
831{
832 unsigned int majv, minv;
833 const char *pos, *saved;
834 const char *end;
835
836 saved = pos = str;
837 end = str + strlen(str);
838
839 majv = read_uint(&pos, end);
840 if (saved == pos || *pos++ != '.')
841 return -1;
842
843 saved = pos;
844 minv = read_uint(&pos, end);
845 if (saved == pos || pos != end)
846 return -1;
847
848 *maj_ver = majv;
849 *min_ver = minv;
850
851 return 0;
852}
Emeric Brun2b920a12010-09-23 18:30:22 +0200853
854/*
Frédéric Lécaillece025572019-01-21 13:38:06 +0100855 * Parse a line terminated by an optional '\r' character, followed by a mandatory
856 * '\n' character.
857 * Returns 1 if succeeded or 0 if a '\n' character could not be found, and -1 if
858 * a line could not be read because the communication channel is closed.
859 */
860static inline int peer_getline(struct appctx *appctx)
861{
862 int n;
863 struct stream_interface *si = appctx->owner;
864
865 n = co_getline(si_oc(si), trash.area, trash.size);
866 if (!n)
867 return 0;
868
869 if (n < 0 || trash.area[n - 1] != '\n') {
870 appctx->st0 = PEER_SESS_ST_END;
871 return -1;
872 }
873
874 if (n > 1 && (trash.area[n - 2] == '\r'))
875 trash.area[n - 2] = 0;
876 else
877 trash.area[n - 1] = 0;
878
879 co_skip(si_oc(si), n);
880
881 return n;
882}
883
884/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100885 * Send a message after having called <peer_prepare_msg> to build it.
886 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
887 * Returns -1 if there was not enough room left to send the message,
888 * any other negative returned value must be considered as an error with an appcxt st0
889 * returned value equal to PEER_SESS_ST_END.
890 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100891static inline int peer_send_msg(struct appctx *appctx,
892 int (*peer_prepare_msg)(char *, size_t, struct peer_prep_params *),
893 struct peer_prep_params *params)
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100894{
895 int ret, msglen;
896 struct stream_interface *si = appctx->owner;
897
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100898 msglen = peer_prepare_msg(trash.area, trash.size, params);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100899 if (!msglen) {
900 /* internal error: message does not fit in trash */
901 appctx->st0 = PEER_SESS_ST_END;
902 return 0;
903 }
904
905 /* message to buffer */
906 ret = ci_putblk(si_ic(si), trash.area, msglen);
907 if (ret <= 0) {
908 if (ret == -1) {
909 /* No more write possible */
910 si_rx_room_blk(si);
911 return -1;
912 }
913 appctx->st0 = PEER_SESS_ST_END;
914 }
915
916 return ret;
917}
918
919/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100920 * Send a hello message.
921 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
922 * Returns -1 if there was not enough room left to send the message,
923 * any other negative returned value must be considered as an error with an appcxt st0
924 * returned value equal to PEER_SESS_ST_END.
925 */
926static inline int peer_send_hellomsg(struct appctx *appctx, struct peer *peer)
927{
928 struct peer_prep_params p = {
929 .hello.peer = peer,
930 };
931
932 return peer_send_msg(appctx, peer_prepare_hellomsg, &p);
933}
934
935/*
936 * Send a success peer handshake status message.
937 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
938 * Returns -1 if there was not enough room left to send the message,
939 * any other negative returned value must be considered as an error with an appcxt st0
940 * returned value equal to PEER_SESS_ST_END.
941 */
942static inline int peer_send_status_successmsg(struct appctx *appctx)
943{
944 return peer_send_msg(appctx, peer_prepare_status_successmsg, NULL);
945}
946
947/*
948 * Send a peer handshake status error message.
949 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
950 * Returns -1 if there was not enough room left to send the message,
951 * any other negative returned value must be considered as an error with an appcxt st0
952 * returned value equal to PEER_SESS_ST_END.
953 */
954static inline int peer_send_status_errormsg(struct appctx *appctx)
955{
956 struct peer_prep_params p = {
957 .error_status.st1 = appctx->st1,
958 };
959
960 return peer_send_msg(appctx, peer_prepare_status_errormsg, &p);
961}
962
963/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100964 * Send a stick-table switch message.
965 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
966 * Returns -1 if there was not enough room left to send the message,
967 * any other negative returned value must be considered as an error with an appcxt st0
968 * returned value equal to PEER_SESS_ST_END.
969 */
970static inline int peer_send_switchmsg(struct shared_table *st, struct appctx *appctx)
971{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100972 struct peer_prep_params p = {
973 .swtch.shared_table = st,
974 };
975
976 return peer_send_msg(appctx, peer_prepare_switchmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100977}
978
979/*
980 * Send a stick-table update acknowledgement message.
981 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
982 * Returns -1 if there was not enough room left to send the message,
983 * any other negative returned value must be considered as an error with an appcxt st0
984 * returned value equal to PEER_SESS_ST_END.
985 */
986static inline int peer_send_ackmsg(struct shared_table *st, struct appctx *appctx)
987{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100988 struct peer_prep_params p = {
989 .ack.shared_table = st,
990 };
991
992 return peer_send_msg(appctx, peer_prepare_ackmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100993}
994
995/*
Frédéric Lécaille87f554c2019-01-22 17:26:50 +0100996 * Send a stick-table update message.
997 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
998 * Returns -1 if there was not enough room left to send the message,
999 * any other negative returned value must be considered as an error with an appcxt st0
1000 * returned value equal to PEER_SESS_ST_END.
1001 */
1002static inline int peer_send_updatemsg(struct shared_table *st, struct appctx *appctx, struct stksess *ts,
1003 unsigned int updateid, int use_identifier, int use_timed)
1004{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001005 struct peer_prep_params p = {
1006 .updt.stksess = ts,
1007 .updt.shared_table = st,
1008 .updt.updateid = updateid,
1009 .updt.use_identifier = use_identifier,
1010 .updt.use_timed = use_timed,
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001011 .updt.peer = appctx->ctx.peers.ptr,
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001012 };
1013
1014 return peer_send_msg(appctx, peer_prepare_updatemsg, &p);
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001015}
1016
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001017/*
1018 * Build a peer protocol control class message.
1019 * Returns the number of written bytes used to build the message if succeeded,
1020 * 0 if not.
1021 */
1022static int peer_prepare_control_msg(char *msg, size_t size, struct peer_prep_params *p)
1023{
1024 if (size < sizeof p->control.head)
1025 return 0;
1026
1027 msg[0] = p->control.head[0];
1028 msg[1] = p->control.head[1];
1029
1030 return 2;
1031}
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001032
1033/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001034 * Send a stick-table synchronization request message.
1035 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1036 * Returns -1 if there was not enough room left to send the message,
1037 * any other negative returned value must be considered as an error with an appctx st0
1038 * returned value equal to PEER_SESS_ST_END.
1039 */
1040static inline int peer_send_resync_reqmsg(struct appctx *appctx)
1041{
1042 struct peer_prep_params p = {
1043 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCREQ, },
1044 };
1045
1046 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1047}
1048
1049/*
1050 * Send a stick-table synchronization confirmation message.
1051 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1052 * Returns -1 if there was not enough room left to send the message,
1053 * any other negative returned value must be considered as an error with an appctx st0
1054 * returned value equal to PEER_SESS_ST_END.
1055 */
1056static inline int peer_send_resync_confirmsg(struct appctx *appctx)
1057{
1058 struct peer_prep_params p = {
1059 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCCONFIRM, },
1060 };
1061
1062 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1063}
1064
1065/*
1066 * Send a stick-table synchronization finished message.
1067 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1068 * Returns -1 if there was not enough room left to send the message,
1069 * any other negative returned value must be considered as an error with an appctx st0
1070 * returned value equal to PEER_SESS_ST_END.
1071 */
Emeric Brun70de43b2020-03-16 10:51:01 +01001072static inline int peer_send_resync_finishedmsg(struct appctx *appctx, struct peers *peers)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001073{
1074 struct peer_prep_params p = {
1075 .control.head = { PEER_MSG_CLASS_CONTROL, },
1076 };
1077
Emeric Brun70de43b2020-03-16 10:51:01 +01001078 p.control.head[1] = (peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED ?
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001079 PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
1080
1081 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1082}
1083
1084/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001085 * Send a heartbeat message.
1086 * Return 0 if the message could not be built modifying the appctx st0 to PEER_SESS_ST_END value.
1087 * Returns -1 if there was not enough room left to send the message,
1088 * any other negative returned value must be considered as an error with an appctx st0
1089 * returned value equal to PEER_SESS_ST_END.
1090 */
1091static inline int peer_send_heartbeatmsg(struct appctx *appctx)
1092{
1093 struct peer_prep_params p = {
1094 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_HEARTBEAT, },
1095 };
1096
1097 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1098}
1099
1100/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001101 * Build a peer protocol error class message.
1102 * Returns the number of written bytes used to build the message if succeeded,
1103 * 0 if not.
1104 */
1105static int peer_prepare_error_msg(char *msg, size_t size, struct peer_prep_params *p)
1106{
1107 if (size < sizeof p->error.head)
1108 return 0;
1109
1110 msg[0] = p->error.head[0];
1111 msg[1] = p->error.head[1];
1112
1113 return 2;
1114}
1115
1116/*
1117 * Send a "size limit reached" error message.
1118 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1119 * Returns -1 if there was not enough room left to send the message,
1120 * any other negative returned value must be considered as an error with an appctx st0
1121 * returned value equal to PEER_SESS_ST_END.
1122 */
1123static inline int peer_send_error_size_limitmsg(struct appctx *appctx)
1124{
1125 struct peer_prep_params p = {
1126 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_SIZELIMIT, },
1127 };
1128
1129 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1130}
1131
1132/*
1133 * Send a "peer protocol" error message.
1134 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1135 * Returns -1 if there was not enough room left to send the message,
1136 * any other negative returned value must be considered as an error with an appctx st0
1137 * returned value equal to PEER_SESS_ST_END.
1138 */
1139static inline int peer_send_error_protomsg(struct appctx *appctx)
1140{
1141 struct peer_prep_params p = {
1142 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_PROTOCOL, },
1143 };
1144
1145 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1146}
1147
1148/*
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001149 * Function used to lookup for recent stick-table updates associated with
1150 * <st> shared stick-table when a lesson must be taught a peer (PEER_F_LEARN_ASSIGN flag set).
1151 */
1152static inline struct stksess *peer_teach_process_stksess_lookup(struct shared_table *st)
1153{
1154 struct eb32_node *eb;
1155
1156 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1157 if (!eb) {
1158 eb = eb32_first(&st->table->updates);
1159 if (!eb || ((int)(eb->key - st->last_pushed) <= 0)) {
1160 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1161 return NULL;
1162 }
1163 }
1164
1165 if ((int)(eb->key - st->table->localupdate) > 0) {
1166 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1167 return NULL;
1168 }
1169
1170 return eb32_entry(eb, struct stksess, upd);
1171}
1172
1173/*
1174 * Function used to lookup for recent stick-table updates associated with
1175 * <st> shared stick-table during teach state 1 step.
1176 */
1177static inline struct stksess *peer_teach_stage1_stksess_lookup(struct shared_table *st)
1178{
1179 struct eb32_node *eb;
1180
1181 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1182 if (!eb) {
1183 st->flags |= SHTABLE_F_TEACH_STAGE1;
1184 eb = eb32_first(&st->table->updates);
1185 if (eb)
1186 st->last_pushed = eb->key - 1;
1187 return NULL;
1188 }
1189
1190 return eb32_entry(eb, struct stksess, upd);
1191}
1192
1193/*
1194 * Function used to lookup for recent stick-table updates associated with
1195 * <st> shared stick-table during teach state 2 step.
1196 */
1197static inline struct stksess *peer_teach_stage2_stksess_lookup(struct shared_table *st)
1198{
1199 struct eb32_node *eb;
1200
1201 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1202 if (!eb || eb->key > st->teaching_origin) {
1203 st->flags |= SHTABLE_F_TEACH_STAGE2;
1204 return NULL;
1205 }
1206
1207 return eb32_entry(eb, struct stksess, upd);
1208}
1209
1210/*
1211 * Generic function to emit update messages for <st> stick-table when a lesson must
1212 * be taught to the peer <p>.
1213 * <locked> must be set to 1 if the shared table <st> is already locked when entering
1214 * this function, 0 if not.
1215 *
1216 * This function temporary unlock/lock <st> when it sends stick-table updates or
1217 * when decrementing its refcount in case of any error when it sends this updates.
1218 *
1219 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1220 * Returns -1 if there was not enough room left to send the message,
1221 * any other negative returned value must be considered as an error with an appcxt st0
1222 * returned value equal to PEER_SESS_ST_END.
1223 * If it returns 0 or -1, this function leave <st> locked if already locked when entering this function
1224 * unlocked if not already locked when entering this function.
1225 */
1226static inline int peer_send_teachmsgs(struct appctx *appctx, struct peer *p,
1227 struct stksess *(*peer_stksess_lookup)(struct shared_table *),
1228 struct shared_table *st, int locked)
1229{
1230 int ret, new_pushed, use_timed;
1231
1232 ret = 1;
1233 use_timed = 0;
1234 if (st != p->last_local_table) {
1235 ret = peer_send_switchmsg(st, appctx);
1236 if (ret <= 0)
1237 return ret;
1238
1239 p->last_local_table = st;
1240 }
1241
1242 if (peer_stksess_lookup != peer_teach_process_stksess_lookup)
1243 use_timed = !(p->flags & PEER_F_DWNGRD);
1244
1245 /* We force new pushed to 1 to force identifier in update message */
1246 new_pushed = 1;
1247
1248 if (!locked)
1249 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1250
1251 while (1) {
1252 struct stksess *ts;
1253 unsigned updateid;
1254
1255 /* push local updates */
1256 ts = peer_stksess_lookup(st);
1257 if (!ts)
1258 break;
1259
1260 updateid = ts->upd.key;
1261 ts->ref_cnt++;
1262 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1263
1264 ret = peer_send_updatemsg(st, appctx, ts, updateid, new_pushed, use_timed);
1265 if (ret <= 0) {
1266 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1267 ts->ref_cnt--;
1268 if (!locked)
1269 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1270 return ret;
1271 }
1272
1273 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1274 ts->ref_cnt--;
1275 st->last_pushed = updateid;
1276
1277 if (peer_stksess_lookup == peer_teach_process_stksess_lookup &&
1278 (int)(st->last_pushed - st->table->commitupdate) > 0)
1279 st->table->commitupdate = st->last_pushed;
1280
1281 /* identifier may not needed in next update message */
1282 new_pushed = 0;
1283 }
1284
1285 out:
1286 if (!locked)
1287 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1288 return 1;
1289}
1290
1291/*
1292 * Function to emit update messages for <st> stick-table when a lesson must
1293 * be taught to the peer <p> (PEER_F_LEARN_ASSIGN flag set).
1294 *
1295 * Note that <st> shared stick-table is locked when calling this function.
1296 *
1297 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1298 * Returns -1 if there was not enough room left to send the message,
1299 * any other negative returned value must be considered as an error with an appcxt st0
1300 * returned value equal to PEER_SESS_ST_END.
1301 */
1302static inline int peer_send_teach_process_msgs(struct appctx *appctx, struct peer *p,
1303 struct shared_table *st)
1304{
1305 return peer_send_teachmsgs(appctx, p, peer_teach_process_stksess_lookup, st, 1);
1306}
1307
1308/*
1309 * Function to emit update messages for <st> stick-table when a lesson must
1310 * be taught to the peer <p> during teach state 1 step.
1311 *
1312 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1313 * Returns -1 if there was not enough room left to send the message,
1314 * any other negative returned value must be considered as an error with an appcxt st0
1315 * returned value equal to PEER_SESS_ST_END.
1316 */
1317static inline int peer_send_teach_stage1_msgs(struct appctx *appctx, struct peer *p,
1318 struct shared_table *st)
1319{
1320 return peer_send_teachmsgs(appctx, p, peer_teach_stage1_stksess_lookup, st, 0);
1321}
1322
1323/*
1324 * Function to emit update messages for <st> stick-table when a lesson must
1325 * be taught to the peer <p> during teach state 1 step.
1326 *
1327 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1328 * Returns -1 if there was not enough room left to send the message,
1329 * any other negative returned value must be considered as an error with an appcxt st0
1330 * returned value equal to PEER_SESS_ST_END.
1331 */
1332static inline int peer_send_teach_stage2_msgs(struct appctx *appctx, struct peer *p,
1333 struct shared_table *st)
1334{
1335 return peer_send_teachmsgs(appctx, p, peer_teach_stage2_stksess_lookup, st, 0);
1336}
1337
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001338
1339/*
1340 * Function used to parse a stick-table update message after it has been received
1341 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1342 * receipt buffer with <msg_end> being position of the end of the stick-table message.
1343 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1344 * was encountered.
1345 * <exp> must be set if the stick-table entry expires.
1346 * <updt> must be set for PEER_MSG_STKT_UPDATE or PEER_MSG_STKT_UPDATE_TIMED stick-table
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001347 * 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 +01001348 * update ID.
1349 * <totl> is the length of the stick-table update message computed upon receipt.
1350 */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001351static int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int exp,
1352 char **msg_cur, char *msg_end, int msg_len, int totl)
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001353{
1354 struct stream_interface *si = appctx->owner;
1355 struct shared_table *st = p->remote_table;
1356 struct stksess *ts, *newts;
1357 uint32_t update;
1358 int expire;
1359 unsigned int data_type;
1360 void *data_ptr;
1361
1362 /* Here we have data message */
1363 if (!st)
1364 goto ignore_msg;
1365
1366 expire = MS_TO_TICKS(st->table->expire);
1367
1368 if (updt) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001369 if (msg_len < sizeof(update))
1370 goto malformed_exit;
1371
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001372 memcpy(&update, *msg_cur, sizeof(update));
1373 *msg_cur += sizeof(update);
1374 st->last_get = htonl(update);
1375 }
1376 else {
1377 st->last_get++;
1378 }
1379
1380 if (exp) {
1381 size_t expire_sz = sizeof expire;
1382
Willy Tarreau1e82a142019-01-29 11:08:06 +01001383 if (*msg_cur + expire_sz > msg_end)
1384 goto malformed_exit;
1385
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001386 memcpy(&expire, *msg_cur, expire_sz);
1387 *msg_cur += expire_sz;
1388 expire = ntohl(expire);
1389 }
1390
1391 newts = stksess_new(st->table, NULL);
1392 if (!newts)
1393 goto ignore_msg;
1394
1395 if (st->table->type == SMP_T_STR) {
1396 unsigned int to_read, to_store;
1397
1398 to_read = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001399 if (!*msg_cur)
1400 goto malformed_free_newts;
1401
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001402 to_store = MIN(to_read, st->table->key_size - 1);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001403 if (*msg_cur + to_store > msg_end)
1404 goto malformed_free_newts;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001405
1406 memcpy(newts->key.key, *msg_cur, to_store);
1407 newts->key.key[to_store] = 0;
1408 *msg_cur += to_read;
1409 }
1410 else if (st->table->type == SMP_T_SINT) {
1411 unsigned int netinteger;
1412
Willy Tarreau1e82a142019-01-29 11:08:06 +01001413 if (*msg_cur + sizeof(netinteger) > msg_end)
1414 goto malformed_free_newts;
1415
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001416 memcpy(&netinteger, *msg_cur, sizeof(netinteger));
1417 netinteger = ntohl(netinteger);
1418 memcpy(newts->key.key, &netinteger, sizeof(netinteger));
1419 *msg_cur += sizeof(netinteger);
1420 }
1421 else {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001422 if (*msg_cur + st->table->key_size > msg_end)
1423 goto malformed_free_newts;
1424
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001425 memcpy(newts->key.key, *msg_cur, st->table->key_size);
1426 *msg_cur += st->table->key_size;
1427 }
1428
1429 /* lookup for existing entry */
1430 ts = stktable_set_entry(st->table, newts);
1431 if (ts != newts) {
1432 stksess_free(st->table, newts);
1433 newts = NULL;
1434 }
1435
1436 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
1437
1438 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001439 uint64_t decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001440
1441 if (!((1 << data_type) & st->remote_data))
1442 continue;
1443
Willy Tarreau1e82a142019-01-29 11:08:06 +01001444 decoded_int = intdecode(msg_cur, msg_end);
1445 if (!*msg_cur)
1446 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001447
Willy Tarreau1e82a142019-01-29 11:08:06 +01001448 switch (stktable_data_types[data_type].std_type) {
1449 case STD_T_SINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001450 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1451 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001452 stktable_data_cast(data_ptr, std_t_sint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001453 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001454
Willy Tarreau1e82a142019-01-29 11:08:06 +01001455 case STD_T_UINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001456 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1457 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001458 stktable_data_cast(data_ptr, std_t_uint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001459 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001460
Willy Tarreau1e82a142019-01-29 11:08:06 +01001461 case STD_T_ULL:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001462 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1463 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001464 stktable_data_cast(data_ptr, std_t_ull) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001465 break;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001466
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001467 case STD_T_FRQP: {
1468 struct freq_ctr_period data;
1469
1470 /* First bit is reserved for the freq_ctr_period lock
1471 Note: here we're still protected by the stksess lock
1472 so we don't need to update the update the freq_ctr_period
1473 using its internal lock */
1474
Willy Tarreau1e82a142019-01-29 11:08:06 +01001475 data.curr_tick = tick_add(now_ms, -decoded_int) & ~0x1;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001476 data.curr_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001477 if (!*msg_cur)
1478 goto malformed_unlock;
1479
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001480 data.prev_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001481 if (!*msg_cur)
1482 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001483
1484 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1485 if (data_ptr)
1486 stktable_data_cast(data_ptr, std_t_frqp) = data;
1487 break;
1488 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001489 case STD_T_DICT: {
1490 struct buffer *chunk;
1491 size_t data_len, value_len;
1492 unsigned int id;
1493 struct dict_entry *de;
1494 struct dcache *dc;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001495 char *end;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001496
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +01001497 if (!decoded_int) {
1498 /* No entry. */
1499 break;
1500 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001501 data_len = decoded_int;
1502 if (*msg_cur + data_len > msg_end)
1503 goto malformed_unlock;
1504
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001505 /* Compute the end of the current data, <msg_end> being at the end of
1506 * the entire message.
1507 */
1508 end = *msg_cur + data_len;
1509 id = intdecode(msg_cur, end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001510 if (!*msg_cur || !id)
1511 goto malformed_unlock;
1512
1513 dc = p->dcache;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001514 if (*msg_cur == end) {
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001515 /* Dictionary entry key without value. */
1516 if (id > dc->max_entries)
1517 break;
1518 /* IDs sent over the network are numbered from 1. */
1519 de = dc->rx[id - 1].de;
1520 }
1521 else {
1522 chunk = get_trash_chunk();
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001523 value_len = intdecode(msg_cur, end);
1524 if (!*msg_cur || *msg_cur + value_len > end ||
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001525 unlikely(value_len + 1 >= chunk->size))
1526 goto malformed_unlock;
1527
1528 chunk_memcpy(chunk, *msg_cur, value_len);
1529 chunk->area[chunk->data] = '\0';
Frédéric Lécaille56aec0d2019-06-06 14:14:15 +02001530 *msg_cur += value_len;
1531
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001532 de = dict_insert(&server_name_dict, chunk->area);
1533 dc->rx[id - 1].de = de;
1534 }
1535 if (de) {
1536 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1537 if (data_ptr)
1538 stktable_data_cast(data_ptr, std_t_dict) = de;
1539 }
1540 break;
1541 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001542 }
1543 }
1544 /* Force new expiration */
1545 ts->expire = tick_add(now_ms, expire);
1546
1547 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1548 stktable_touch_remote(st->table, ts, 1);
1549 return 1;
1550
1551 ignore_msg:
1552 /* skip consumed message */
1553 co_skip(si_oc(si), totl);
1554 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001555
1556 malformed_unlock:
1557 /* malformed message */
1558 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1559 stktable_touch_remote(st->table, ts, 1);
1560 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1561 return 0;
1562
1563 malformed_free_newts:
1564 /* malformed message */
1565 stksess_free(st->table, newts);
1566 malformed_exit:
1567 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1568 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001569}
1570
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001571/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001572 * Function used to parse a stick-table update acknowledgement message after it
1573 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1574 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1575 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1576 * was encountered.
1577 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1578 */
1579static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1580 char **msg_cur, char *msg_end)
1581{
1582 /* ack message */
1583 uint32_t table_id ;
1584 uint32_t update;
1585 struct shared_table *st;
1586
1587 table_id = intdecode(msg_cur, msg_end);
1588 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1589 /* malformed message */
1590 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1591 return 0;
1592 }
1593
1594 memcpy(&update, *msg_cur, sizeof(update));
1595 update = ntohl(update);
1596
1597 for (st = p->tables; st; st = st->next) {
1598 if (st->local_id == table_id) {
1599 st->update = update;
1600 break;
1601 }
1602 }
1603
1604 return 1;
1605}
1606
1607/*
1608 * Function used to parse a stick-table switch message after it has been received
1609 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1610 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1611 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1612 * was encountered.
1613 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1614 */
1615static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1616 char **msg_cur, char *msg_end)
1617{
1618 struct shared_table *st;
1619 int table_id;
1620
1621 table_id = intdecode(msg_cur, msg_end);
1622 if (!*msg_cur) {
1623 /* malformed message */
1624 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1625 return 0;
1626 }
1627
1628 p->remote_table = NULL;
1629 for (st = p->tables; st; st = st->next) {
1630 if (st->remote_id == table_id) {
1631 p->remote_table = st;
1632 break;
1633 }
1634 }
1635
1636 return 1;
1637}
1638
1639/*
1640 * Function used to parse a stick-table definition message after it has been received
1641 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1642 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1643 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1644 * was encountered.
1645 * <totl> is the length of the stick-table update message computed upon receipt.
1646 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1647 */
1648static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1649 char **msg_cur, char *msg_end, int totl)
1650{
1651 struct stream_interface *si = appctx->owner;
1652 int table_id_len;
1653 struct shared_table *st;
1654 int table_type;
1655 int table_keylen;
1656 int table_id;
1657 uint64_t table_data;
1658
1659 table_id = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001660 if (!*msg_cur)
1661 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001662
1663 table_id_len = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001664 if (!*msg_cur)
1665 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001666
1667 p->remote_table = NULL;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001668 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end)
1669 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001670
1671 for (st = p->tables; st; st = st->next) {
1672 /* Reset IDs */
1673 if (st->remote_id == table_id)
1674 st->remote_id = 0;
1675
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001676 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1677 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001678 p->remote_table = st;
1679 }
1680
1681 if (!p->remote_table)
1682 goto ignore_msg;
1683
1684 *msg_cur += table_id_len;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001685 if (*msg_cur >= msg_end)
1686 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001687
1688 table_type = 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
1692 table_keylen = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001693 if (!*msg_cur)
1694 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001695
1696 table_data = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001697 if (!*msg_cur)
1698 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001699
Emeric Brun530ba382020-06-02 11:17:42 +02001700 if (p->remote_table->table->type != peer_int_key_type[table_type]
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001701 || p->remote_table->table->key_size != table_keylen) {
1702 p->remote_table = NULL;
1703 goto ignore_msg;
1704 }
1705
1706 p->remote_table->remote_data = table_data;
1707 p->remote_table->remote_id = table_id;
1708 return 1;
1709
1710 ignore_msg:
1711 co_skip(si_oc(si), totl);
1712 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001713
1714 malformed_exit:
1715 /* malformed message */
1716 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1717 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001718}
1719
1720/*
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001721 * Receive a stick-table message.
1722 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1723 * -1 if there was an error updating the appctx state st0 accordingly.
1724 */
1725static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1726 uint32_t *msg_len, int *totl)
1727{
1728 int reql;
1729 struct stream_interface *si = appctx->owner;
1730
1731 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1732 if (reql <= 0) /* closed or EOL not found */
1733 goto incomplete;
1734
1735 *totl += reql;
1736
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001737 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001738 return 1;
1739
1740 /* Read and Decode message length */
1741 reql = co_getblk(si_oc(si), &msg_head[2], sizeof(char), *totl);
1742 if (reql <= 0) /* closed */
1743 goto incomplete;
1744
1745 *totl += reql;
1746
Frédéric Lécaille32b55732019-06-03 18:29:51 +02001747 if ((unsigned int)msg_head[2] < PEER_ENC_2BYTES_MIN) {
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001748 *msg_len = msg_head[2];
1749 }
1750 else {
1751 int i;
1752 char *cur;
1753 char *end;
1754
1755 for (i = 3 ; i < msg_head_sz ; i++) {
1756 reql = co_getblk(si_oc(si), &msg_head[i], sizeof(char), *totl);
1757 if (reql <= 0) /* closed */
1758 goto incomplete;
1759
1760 *totl += reql;
1761
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001762 if (!(msg_head[i] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001763 break;
1764 }
1765
1766 if (i == msg_head_sz) {
1767 /* malformed message */
1768 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1769 return -1;
1770 }
1771 end = msg_head + msg_head_sz;
1772 cur = &msg_head[2];
1773 *msg_len = intdecode(&cur, end);
1774 if (!cur) {
1775 /* malformed message */
1776 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1777 return -1;
1778 }
1779 }
1780
1781 /* Read message content */
1782 if (*msg_len) {
1783 if (*msg_len > trash.size) {
1784 /* Status code is not success, abort */
1785 appctx->st0 = PEER_SESS_ST_ERRSIZE;
1786 return -1;
1787 }
1788
1789 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
1790 if (reql <= 0) /* closed */
1791 goto incomplete;
1792 *totl += reql;
1793 }
1794
1795 return 1;
1796
1797 incomplete:
1798 if (reql < 0) {
1799 /* there was an error */
1800 appctx->st0 = PEER_SESS_ST_END;
1801 return -1;
1802 }
1803
1804 return 0;
1805}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001806
1807/*
1808 * Treat the awaited message with <msg_head> as header.*
1809 * Return 1 if succeeded, 0 if not.
1810 */
1811static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
1812 char **msg_cur, char *msg_end, int msg_len, int totl)
1813{
1814 struct stream_interface *si = appctx->owner;
1815 struct stream *s = si_strm(si);
1816 struct peers *peers = strm_fe(s)->parent;
1817
1818 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
1819 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
1820 struct shared_table *st;
1821 /* Reset message: remote need resync */
1822
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001823 /* prepare tables for a global push */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001824 for (st = peer->tables; st; st = st->next) {
1825 st->teaching_origin = st->last_pushed = st->table->update;
1826 st->flags = 0;
1827 }
1828
1829 /* reset teaching flags to 0 */
1830 peer->flags &= PEER_TEACH_RESET;
1831
1832 /* flag to start to teach lesson */
1833 peer->flags |= PEER_F_TEACH_PROCESS;
1834 }
1835 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
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 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
1840 }
1841 peer->confirm++;
1842 }
1843 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
1844 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1845 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1846 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1847
1848 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001849 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001850 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
1851 }
1852 peer->confirm++;
1853 }
1854 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
1855 struct shared_table *st;
1856
1857 /* If stopping state */
1858 if (stopping) {
1859 /* Close session, push resync no more needed */
1860 peer->flags |= PEER_F_TEACH_COMPLETE;
1861 appctx->st0 = PEER_SESS_ST_END;
1862 return 0;
1863 }
1864 for (st = peer->tables; st; st = st->next) {
1865 st->update = st->last_pushed = st->teaching_origin;
1866 st->flags = 0;
1867 }
1868
1869 /* reset teaching flags to 0 */
1870 peer->flags &= PEER_TEACH_RESET;
1871 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001872 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001873 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01001874 peer->rx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001875 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001876 }
1877 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
1878 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
1879 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
1880 return 0;
1881 }
1882 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
1883 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
1884 return 0;
1885 }
1886 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
1887 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
1888 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
1889 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
1890 int update, expire;
1891
1892 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
1893 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
1894 if (!peer_treat_updatemsg(appctx, peer, update, expire,
1895 msg_cur, msg_end, msg_len, totl))
1896 return 0;
1897
1898 }
1899 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
1900 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
1901 return 0;
1902 }
1903 }
1904 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
1905 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1906 return 0;
1907 }
1908
1909 return 1;
1910}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001911
1912
1913/*
1914 * Send any message to <peer> peer.
1915 * Returns 1 if succeeded, or -1 or 0 if failed.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001916 * -1 means an internal error occurred, 0 is for a peer protocol error leading
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001917 * to a peer state change (from the peer I/O handler point of view).
1918 */
1919static inline int peer_send_msgs(struct appctx *appctx, struct peer *peer)
1920{
1921 int repl;
1922 struct stream_interface *si = appctx->owner;
1923 struct stream *s = si_strm(si);
1924 struct peers *peers = strm_fe(s)->parent;
1925
1926 /* Need to request a resync */
1927 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
1928 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
1929 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
1930
1931 repl = peer_send_resync_reqmsg(appctx);
1932 if (repl <= 0)
1933 return repl;
1934
1935 peers->flags |= PEERS_F_RESYNC_PROCESS;
1936 }
1937
1938 /* Nothing to read, now we start to write */
1939 if (peer->tables) {
1940 struct shared_table *st;
1941 struct shared_table *last_local_table;
1942
1943 last_local_table = peer->last_local_table;
1944 if (!last_local_table)
1945 last_local_table = peer->tables;
1946 st = last_local_table->next;
1947
1948 while (1) {
1949 if (!st)
1950 st = peer->tables;
1951
1952 /* It remains some updates to ack */
1953 if (st->last_get != st->last_acked) {
1954 repl = peer_send_ackmsg(st, appctx);
1955 if (repl <= 0)
1956 return repl;
1957
1958 st->last_acked = st->last_get;
1959 }
1960
1961 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
1962 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1963 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
1964 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
1965
1966 repl = peer_send_teach_process_msgs(appctx, peer, st);
1967 if (repl <= 0) {
1968 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1969 return repl;
1970 }
1971 }
1972 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1973 }
1974 else {
1975 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
1976 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
1977 if (repl <= 0)
1978 return repl;
1979 }
1980
1981 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
1982 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
1983 if (repl <= 0)
1984 return repl;
1985 }
1986 }
1987
1988 if (st == last_local_table)
1989 break;
1990 st = st->next;
1991 }
1992 }
1993
1994 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
Emeric Brun70de43b2020-03-16 10:51:01 +01001995 repl = peer_send_resync_finishedmsg(appctx, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001996 if (repl <= 0)
1997 return repl;
1998
1999 /* flag finished message sent */
2000 peer->flags |= PEER_F_TEACH_FINISHED;
2001 }
2002
2003 /* Confirm finished or partial messages */
2004 while (peer->confirm) {
2005 repl = peer_send_resync_confirmsg(appctx);
2006 if (repl <= 0)
2007 return repl;
2008
2009 peer->confirm--;
2010 }
2011
2012 return 1;
2013}
2014
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002015/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002016 * Read and parse a first line of a "hello" peer protocol message.
2017 * Returns 0 if could not read a line, -1 if there was a read error or
2018 * the line is malformed, 1 if succeeded.
2019 */
2020static inline int peer_getline_version(struct appctx *appctx,
2021 unsigned int *maj_ver, unsigned int *min_ver)
2022{
2023 int reql;
2024
2025 reql = peer_getline(appctx);
2026 if (!reql)
2027 return 0;
2028
2029 if (reql < 0)
2030 return -1;
2031
2032 /* test protocol */
2033 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
2034 appctx->st0 = PEER_SESS_ST_EXIT;
2035 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2036 return -1;
2037 }
2038 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
2039 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
2040 appctx->st0 = PEER_SESS_ST_EXIT;
2041 appctx->st1 = PEER_SESS_SC_ERRVERSION;
2042 return -1;
2043 }
2044
2045 return 1;
2046}
2047
2048/*
2049 * Read and parse a second line of a "hello" peer protocol message.
2050 * Returns 0 if could not read a line, -1 if there was a read error or
2051 * the line is malformed, 1 if succeeded.
2052 */
2053static inline int peer_getline_host(struct appctx *appctx)
2054{
2055 int reql;
2056
2057 reql = peer_getline(appctx);
2058 if (!reql)
2059 return 0;
2060
2061 if (reql < 0)
2062 return -1;
2063
2064 /* test hostname match */
2065 if (strcmp(localpeer, trash.area) != 0) {
2066 appctx->st0 = PEER_SESS_ST_EXIT;
2067 appctx->st1 = PEER_SESS_SC_ERRHOST;
2068 return -1;
2069 }
2070
2071 return 1;
2072}
2073
2074/*
2075 * Read and parse a last line of a "hello" peer protocol message.
2076 * Returns 0 if could not read a character, -1 if there was a read error or
2077 * the line is malformed, 1 if succeeded.
2078 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2079 */
2080static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2081{
2082 char *p;
2083 int reql;
2084 struct peer *peer;
2085 struct stream_interface *si = appctx->owner;
2086 struct stream *s = si_strm(si);
2087 struct peers *peers = strm_fe(s)->parent;
2088
2089 reql = peer_getline(appctx);
2090 if (!reql)
2091 return 0;
2092
2093 if (reql < 0)
2094 return -1;
2095
2096 /* parse line "<peer name> <pid> <relative_pid>" */
2097 p = strchr(trash.area, ' ');
2098 if (!p) {
2099 appctx->st0 = PEER_SESS_ST_EXIT;
2100 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2101 return -1;
2102 }
2103 *p = 0;
2104
2105 /* lookup known peer */
2106 for (peer = peers->remote; peer; peer = peer->next) {
2107 if (strcmp(peer->id, trash.area) == 0)
2108 break;
2109 }
2110
2111 /* if unknown peer */
2112 if (!peer) {
2113 appctx->st0 = PEER_SESS_ST_EXIT;
2114 appctx->st1 = PEER_SESS_SC_ERRPEER;
2115 return -1;
2116 }
2117 *curpeer = peer;
2118
2119 return 1;
2120}
2121
2122/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002123 * Init <peer> peer after having accepted it at peer protocol level.
2124 */
2125static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2126{
2127 struct shared_table *st;
2128
2129 /* Register status code */
2130 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
2131
2132 /* Awake main task */
2133 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2134
2135 /* Init confirm counter */
2136 peer->confirm = 0;
2137
2138 /* Init cursors */
2139 for (st = peer->tables; st ; st = st->next) {
2140 st->last_get = st->last_acked = 0;
2141 st->teaching_origin = st->last_pushed = st->update;
2142 }
2143
2144 /* reset teaching and learning flags to 0 */
2145 peer->flags &= PEER_TEACH_RESET;
2146 peer->flags &= PEER_LEARN_RESET;
2147
2148 /* if current peer is local */
2149 if (peer->local) {
2150 /* if current host need resyncfrom local and no process assined */
2151 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2152 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2153 /* assign local peer for a lesson, consider lesson already requested */
2154 peer->flags |= PEER_F_LEARN_ASSIGN;
2155 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2156 }
2157
2158 }
2159 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2160 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2161 /* assign peer for a lesson */
2162 peer->flags |= PEER_F_LEARN_ASSIGN;
2163 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2164 }
2165}
2166
2167/*
2168 * Init <peer> peer after having connected it at peer protocol level.
2169 */
2170static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2171{
2172 struct shared_table *st;
2173
2174 /* Init cursors */
2175 for (st = peer->tables; st ; st = st->next) {
2176 st->last_get = st->last_acked = 0;
2177 st->teaching_origin = st->last_pushed = st->update;
2178 }
2179
2180 /* Init confirm counter */
2181 peer->confirm = 0;
2182
2183 /* reset teaching and learning flags to 0 */
2184 peer->flags &= PEER_TEACH_RESET;
2185 peer->flags &= PEER_LEARN_RESET;
2186
2187 /* If current peer is local */
2188 if (peer->local) {
2189 /* flag to start to teach lesson */
2190 peer->flags |= PEER_F_TEACH_PROCESS;
2191 }
2192 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2193 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2194 /* If peer is remote and resync from remote is needed,
2195 and no peer currently assigned */
2196
2197 /* assign peer for a lesson */
2198 peer->flags |= PEER_F_LEARN_ASSIGN;
2199 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2200 }
2201}
2202
2203/*
Emeric Brun2b920a12010-09-23 18:30:22 +02002204 * IO Handler to handle message exchance with a peer
2205 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002206static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002207{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002208 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002209 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002210 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002211 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002212 int reql = 0;
2213 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002214 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002215 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002216
Joseph Herlant82b2f542018-11-15 12:19:14 -08002217 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002218 if (si_ic(si)->buf.size == 0) {
2219 si_rx_room_blk(si);
2220 goto out;
2221 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002222
Emeric Brun2b920a12010-09-23 18:30:22 +02002223 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002224 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002225switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002226 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002227 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002228 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002229 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002230 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002231 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002232 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002233 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002234 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002235 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2236 if (reql <= 0) {
2237 if (!reql)
2238 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002239 goto switchstate;
2240 }
2241
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002242 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002243 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002244 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002245 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002246 reql = peer_getline_host(appctx);
2247 if (reql <= 0) {
2248 if (!reql)
2249 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002250 goto switchstate;
2251 }
2252
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002253 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002254 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002255 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002256 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002257 reql = peer_getline_last(appctx, &curpeer);
2258 if (reql <= 0) {
2259 if (!reql)
2260 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002261 goto switchstate;
2262 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002263
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002264 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002265 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002266 if (curpeer->local) {
2267 /* Local connection, reply a retry */
2268 appctx->st0 = PEER_SESS_ST_EXIT;
2269 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2270 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002271 }
Emeric Brun80527f52017-06-19 17:46:37 +02002272
2273 /* we're killing a connection, we must apply a random delay before
2274 * retrying otherwise the other end will do the same and we can loop
2275 * for a while.
2276 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002277 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002278 peer_session_forceshutdown(curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002279 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002280 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2281 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2282 curpeer->flags |= PEER_F_DWNGRD;
2283 }
2284 else {
2285 curpeer->flags &= ~PEER_F_DWNGRD;
2286 }
2287 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002288 curpeer->appctx = appctx;
2289 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002290 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002291 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002292 /* fall through */
2293 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002294 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002295 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002296 if (!curpeer) {
2297 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002298 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002299 if (curpeer->appctx != appctx) {
2300 appctx->st0 = PEER_SESS_ST_END;
2301 goto switchstate;
2302 }
2303 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002304
2305 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002306 if (repl <= 0) {
2307 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002308 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002309 goto switchstate;
2310 }
2311
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002312 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002313
Emeric Brun2b920a12010-09-23 18:30:22 +02002314 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002315 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002316 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002317 goto switchstate;
2318 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002319 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002320 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002321 if (!curpeer) {
2322 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002323 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002324 if (curpeer->appctx != appctx) {
2325 appctx->st0 = PEER_SESS_ST_END;
2326 goto switchstate;
2327 }
2328 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002329
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002330 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002331 if (repl <= 0) {
2332 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002333 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002334 goto switchstate;
2335 }
2336
2337 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002338 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002339 /* fall through */
2340 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002341 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002342 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002343 if (!curpeer) {
2344 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002345 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002346 if (curpeer->appctx != appctx) {
2347 appctx->st0 = PEER_SESS_ST_END;
2348 goto switchstate;
2349 }
2350 }
2351
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002352 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002353 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002354
Frédéric Lécaillece025572019-01-21 13:38:06 +01002355 reql = peer_getline(appctx);
2356 if (!reql)
2357 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002358
Frédéric Lécaillece025572019-01-21 13:38:06 +01002359 if (reql < 0)
2360 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002361
2362 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002363 curpeer->statuscode = atoi(trash.area);
Emeric Brun2b920a12010-09-23 18:30:22 +02002364
2365 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002366 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002367
2368 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002369 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002370 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002371 }
2372 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002373 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2374 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002375 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002376 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002377 goto switchstate;
2378 }
Olivier Houcharded879892019-03-08 18:53:43 +01002379 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002380 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002381 /* fall through */
2382 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002383 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002384 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002385 char *msg_cur = trash.area;
2386 char *msg_end = trash.area;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002387 unsigned char msg_head[7];
Emeric Brun2b920a12010-09-23 18:30:22 +02002388 int totl = 0;
2389
Willy Tarreau2d372c22018-11-05 17:12:27 +01002390 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002391 if (!curpeer) {
2392 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002393 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002394 if (curpeer->appctx != appctx) {
2395 appctx->st0 = PEER_SESS_ST_END;
2396 goto switchstate;
2397 }
2398 }
2399
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002400 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2401 if (reql <= 0) {
2402 if (reql == -1)
2403 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002404 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002405 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002406
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002407 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002408 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002409 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002410
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002411 curpeer->flags |= PEER_F_ALIVE;
2412
Emeric Brun2b920a12010-09-23 18:30:22 +02002413 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002414 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002415 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002416 goto switchstate;
2417
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002418send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002419 if (curpeer->flags & PEER_F_HEARTBEAT) {
2420 curpeer->flags &= ~PEER_F_HEARTBEAT;
2421 repl = peer_send_heartbeatmsg(appctx);
2422 if (repl <= 0) {
2423 if (repl == -1)
2424 goto out;
2425 goto switchstate;
2426 }
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002427 curpeer->tx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002428 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002429 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002430 repl = peer_send_msgs(appctx, curpeer);
2431 if (repl <= 0) {
2432 if (repl == -1)
2433 goto out;
2434 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002435 }
2436
Emeric Brun2b920a12010-09-23 18:30:22 +02002437 /* noting more to do */
2438 goto out;
2439 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002440 case PEER_SESS_ST_EXIT:
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_status_errormsg(appctx) == -1)
2445 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002446 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002447 goto switchstate;
2448 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002449 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002450 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002451 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002452 if (peer_send_error_size_limitmsg(appctx) == -1)
2453 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002454 appctx->st0 = PEER_SESS_ST_END;
2455 goto switchstate;
2456 }
2457 case PEER_SESS_ST_ERRPROTO: {
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002458 if (curpeer)
2459 curpeer->proto_err++;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002460 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002461 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002462 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002463 if (peer_send_error_protomsg(appctx) == -1)
2464 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002465 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002466 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002467 /* fall through */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002468 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002469 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002470 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002471 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002472 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002473 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002474 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002475 curpeer = NULL;
2476 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002477 si_shutw(si);
2478 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002479 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002480 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002481 }
2482 }
2483 }
2484out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002485 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002486
2487 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002488 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002489 return;
2490}
2491
Willy Tarreau30576452015-04-13 13:50:30 +02002492static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002493 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002494 .name = "<PEER>", /* used for logging */
2495 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002496 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002497};
Emeric Brun2b920a12010-09-23 18:30:22 +02002498
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002499
Emeric Brun2b920a12010-09-23 18:30:22 +02002500/*
2501 * Use this function to force a close of a peer session
2502 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002503static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002504{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002505 struct appctx *appctx = peer->appctx;
2506
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002507 /* Note that the peer sessions which have just been created
2508 * (->st0 == PEER_SESS_ST_CONNECT) must not
2509 * be shutdown, if not, the TCP session will never be closed
2510 * and stay in CLOSE_WAIT state after having been closed by
2511 * the remote side.
2512 */
2513 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002514 return;
2515
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002516 if (appctx->applet != &peer_applet)
2517 return;
2518
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002519 __peer_session_deinit(peer);
2520
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002521 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002522 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002523}
2524
Willy Tarreau91d96282015-03-13 15:47:26 +01002525/* Pre-configures a peers frontend to accept incoming connections */
2526void peers_setup_frontend(struct proxy *fe)
2527{
2528 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002529 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreau91d96282015-03-13 15:47:26 +01002530 fe->maxconn = 0;
2531 fe->conn_retries = CONN_RETRIES;
2532 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002533 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002534 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002535 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002536 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002537}
2538
Emeric Brun2b920a12010-09-23 18:30:22 +02002539/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002540 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002541 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002542static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002543{
Willy Tarreau04b92862017-09-15 11:01:04 +02002544 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002545 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002546 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002547 struct stream *s;
Emeric Brun2b920a12010-09-23 18:30:22 +02002548
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002549 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002550 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Emeric Brunb3971ab2015-05-12 18:49:09 +02002551 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002552 s = NULL;
2553
Emeric Brun1138fd02017-06-19 12:38:55 +02002554 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002555 if (!appctx)
2556 goto out_close;
2557
2558 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002559 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002560
Willy Tarreau04b92862017-09-15 11:01:04 +02002561 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002562 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002563 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002564 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002565 }
2566
Willy Tarreau87787ac2017-08-28 16:22:54 +02002567 if ((s = stream_new(sess, &appctx->obj_type)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002568 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002569 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002570 }
2571
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002572 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002573 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002574 appctx_wakeup(appctx);
2575
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002576 /* initiate an outgoing connection */
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002577 s->target = peer_session_target(peer, s);
2578 if (!sockaddr_alloc(&s->target_addr))
2579 goto out_free_strm;
2580 *s->target_addr = peer->addr;
Willy Tarreau02efeda2019-07-18 17:21:24 +02002581 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Willy Tarreaudbd02672017-12-06 17:39:53 +01002582 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002583
Emeric Brun2b920a12010-09-23 18:30:22 +02002584 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002585 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002586
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002587 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002588
Emeric Brunb3971ab2015-05-12 18:49:09 +02002589 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002590 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002591 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002592 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002593
2594 /* Error unrolling */
Willy Tarreau15b5e142015-04-04 14:38:25 +02002595 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002596 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002597 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002598 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002599 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002600 out_free_appctx:
2601 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002602 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002603 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002604}
2605
2606/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002607 * Task processing function to manage re-connect, peer session
2608 * tasks wakeup on local update and heartbeat.
Emeric Brun2b920a12010-09-23 18:30:22 +02002609 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02002610static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002611{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002612 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002613 struct peer *ps;
2614 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002615
2616 task->expire = TICK_ETERNITY;
2617
Emeric Brunb3971ab2015-05-12 18:49:09 +02002618 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002619 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002620 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002621 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002622 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002623 return NULL;
2624 }
2625
Emeric Brun80527f52017-06-19 17:46:37 +02002626 /* Acquire lock for all peers of the section */
2627 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002628 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002629
Emeric Brun2b920a12010-09-23 18:30:22 +02002630 if (!stopping) {
2631 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002632
2633 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2634 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2635 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002636 /* Resync from local peer needed
2637 no peer was assigned for the lesson
2638 and no old local peer found
2639 or resync timeout expire */
2640
2641 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002642 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002643
2644 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002645 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002646 }
2647
2648 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002649 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002650 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002651 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002652 if (!ps->appctx) {
2653 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002654 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002655 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002656 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002657 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002658 tick_is_expired(ps->reconnect, now_ms))) {
2659 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002660 * or previous peer connection established with success
2661 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002662 * and reconnection timer is expired */
2663
2664 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002665 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002666 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002667 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002668 /* If previous session failed during connection
2669 * but reconnection timer is not expired */
2670
2671 /* reschedule task for reconnect */
2672 task->expire = tick_first(task->expire, ps->reconnect);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002673 ps->new_conn++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002674 }
2675 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002676 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002677 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002678 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002679 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2680 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002681 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2682 /* Resync from a remote is needed
2683 * and no peer was assigned for lesson
2684 * and current peer may be up2date */
2685
2686 /* assign peer for the lesson */
2687 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002688 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002689
Willy Tarreau9df94c22016-10-31 18:42:52 +01002690 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002691 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002692 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002693 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002694 int update_to_push = 0;
2695
Emeric Brunb3971ab2015-05-12 18:49:09 +02002696 /* Awake session if there is data to push */
2697 for (st = ps->tables; st ; st = st->next) {
2698 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002699 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002700 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002701 /* There is no need to send a heartbeat message
2702 * when some updates must be pushed. The remote
2703 * peer will consider <ps> peer as alive when it will
2704 * receive these updates.
2705 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002706 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002707 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002708 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002709 /* We are going to send updates, let's ensure we will
2710 * come back to send heartbeat messages or to reconnect.
2711 */
2712 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002713 appctx_wakeup(ps->appctx);
2714 break;
2715 }
2716 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002717 /* When there are updates to send we do not reconnect
2718 * and do not send heartbeat message either.
2719 */
2720 if (!update_to_push) {
2721 if (tick_is_expired(ps->reconnect, now_ms)) {
2722 if (ps->flags & PEER_F_ALIVE) {
2723 /* This peer was alive during a 'reconnect' period.
2724 * Flag it as not alive again for the next period.
2725 */
2726 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002727 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002728 }
2729 else {
Willy Tarreau52bf8392020-03-08 00:42:37 +01002730 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002731 peer_session_forceshutdown(ps);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002732 ps->no_hbt++;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002733 }
2734 }
2735 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2736 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
2737 ps->flags |= PEER_F_HEARTBEAT;
2738 appctx_wakeup(ps->appctx);
2739 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01002740 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002741 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002742 }
2743 /* else do nothing */
2744 } /* SUCCESSCODE */
2745 } /* !ps->peer->local */
2746 } /* for */
2747
2748 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002749 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2750 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2751 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002752 /* Resync from remote peer needed
2753 * no peer was assigned for the lesson
2754 * and resync timeout expire */
2755
2756 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002757 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002758 }
2759
Emeric Brunb3971ab2015-05-12 18:49:09 +02002760 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002761 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02002762 /* reschedule task to resync timeout if not expired, to ended resync if needed */
2763 if (!tick_is_expired(peers->resync_timeout, now_ms))
2764 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02002765 }
2766 } /* !stopping */
2767 else {
2768 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01002769 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08002770 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002771 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002772 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01002773 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002774 peers->flags |= PEERS_F_DONOTSTOP;
2775 ps = peers->local;
2776 for (st = ps->tables; st ; st = st->next)
2777 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002778 }
2779
2780 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002781 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02002782 /* we're killing a connection, we must apply a random delay before
2783 * retrying otherwise the other end will do the same and we can loop
2784 * for a while.
2785 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002786 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01002787 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002788 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002789 }
2790 }
2791 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002792
Emeric Brunb3971ab2015-05-12 18:49:09 +02002793 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02002794 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002795 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002796 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002797 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002798 peers->flags &= ~PEERS_F_DONOTSTOP;
2799 for (st = ps->tables; st ; st = st->next)
2800 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002801 }
2802 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01002803 else if (!ps->appctx) {
2804 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002805 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002806 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
2807 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
2808 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002809 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002810 * or previous peer connection was successfully established
2811 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02002812 * or during previous connect, peer replies a try again statuscode */
2813
2814 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002815 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002816 }
2817 else {
2818 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002819 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002820 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002821 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002822 peers->flags &= ~PEERS_F_DONOTSTOP;
2823 for (st = ps->tables; st ; st = st->next)
2824 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002825 }
2826 }
2827 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002828 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002829 /* current peer connection is active and established
2830 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002831 for (st = ps->tables; st ; st = st->next) {
2832 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002833 appctx_wakeup(ps->appctx);
2834 break;
2835 }
2836 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002837 }
2838 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02002839
2840 /* Release lock for all peers of the section */
2841 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002842 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002843
Emeric Brun2b920a12010-09-23 18:30:22 +02002844 /* Wakeup for re-connect */
2845 return task;
2846}
2847
Emeric Brunb3971ab2015-05-12 18:49:09 +02002848
Emeric Brun2b920a12010-09-23 18:30:22 +02002849/*
Willy Tarreaud9443442018-10-15 11:18:03 +02002850 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02002851 */
Willy Tarreaud9443442018-10-15 11:18:03 +02002852int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02002853{
Emeric Brun2b920a12010-09-23 18:30:22 +02002854 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02002855
Emeric Brun2b920a12010-09-23 18:30:22 +02002856 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002857 peers->peers_fe->maxconn += 3;
2858 }
2859
Emeric Brunc60def82017-09-27 14:59:38 +02002860 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02002861 if (!peers->sync_task)
2862 return 0;
2863
Emeric Brunb3971ab2015-05-12 18:49:09 +02002864 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002865 peers->sync_task->context = (void *)peers;
2866 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
2867 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02002868 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002869}
2870
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002871/*
2872 * Allocate a cache a dictionary entries used upon transmission.
2873 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002874static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002875{
2876 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002877 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002878
2879 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002880 entries = calloc(max_entries, sizeof *entries);
2881 if (!d || !entries)
2882 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002883
2884 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002885 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002886 d->cached_entries = EB_ROOT_UNIQUE;
2887 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002888
2889 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002890
2891 err:
2892 free(d);
2893 free(entries);
2894 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002895}
2896
2897/*
2898 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
2899 * as maximum of entries.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002900 * Return the dictionary cache if succeeded, NULL if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002901 * Must be deallocated calling free_dcache().
2902 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002903static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002904{
2905 struct dcache_tx *dc_tx;
2906 struct dcache *dc;
2907 struct dcache_rx *dc_rx;
2908
2909 dc = calloc(1, sizeof *dc);
2910 dc_tx = new_dcache_tx(max_entries);
2911 dc_rx = calloc(max_entries, sizeof *dc_rx);
2912 if (!dc || !dc_tx || !dc_rx)
2913 goto err;
2914
2915 dc->tx = dc_tx;
2916 dc->rx = dc_rx;
2917 dc->max_entries = max_entries;
2918
2919 return dc;
2920
2921 err:
2922 free(dc);
2923 free(dc_tx);
2924 free(dc_rx);
2925 return NULL;
2926}
2927
2928/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002929 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
2930 * entries used upon transmission.
2931 * Return the entry if found, NULL if not.
2932 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002933static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
2934 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002935{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002936 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002937}
2938
2939/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002940 * Flush <dc> cache.
2941 * Always succeeds.
2942 */
2943static inline void flush_dcache(struct peer *peer)
2944{
2945 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002946 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002947
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002948 for (i = 0; i < dc->max_entries; i++)
2949 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002950
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002951 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002952}
2953
2954/*
2955 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
2956 * with information provided by <i> dictionary cache entry (especially the value
2957 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002958 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002959 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002960static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002961{
2962 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002963 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002964
2965 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002966
2967 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
2968 o = dc_tx->prev_lookup;
2969 } else {
2970 o = dcache_tx_lookup_value(dc_tx, i);
2971 if (o) {
2972 /* Save it */
2973 dc_tx->prev_lookup = o;
2974 }
2975 }
2976
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002977 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002978 /* Copy the ID. */
2979 i->id = o - dc->tx->entries;
2980 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002981 }
2982
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002983 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002984 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002985
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002986 ebpt_delete(o);
2987 o->key = i->entry.key;
2988 ebpt_insert(&dc_tx->cached_entries, o);
2989 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002990
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002991 /* Update the index for the next entry to put in cache */
2992 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002993
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002994 return o;
2995}
Emeric Brunb3971ab2015-05-12 18:49:09 +02002996
2997/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002998 * Allocate a dictionary cache for each peer of <peers> section.
2999 * Return 1 if succeeded, 0 if not.
3000 */
3001int peers_alloc_dcache(struct peers *peers)
3002{
3003 struct peer *p;
3004
3005 for (p = peers->remote; p; p = p->next) {
3006 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
3007 if (!p->dcache)
3008 return 0;
3009 }
3010
3011 return 1;
3012}
3013
3014/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02003015 * Function used to register a table for sync on a group of peers
3016 *
3017 */
3018void peers_register_table(struct peers *peers, struct stktable *table)
3019{
3020 struct shared_table *st;
3021 struct peer * curpeer;
3022 int id = 0;
3023
3024 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003025 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003026 st->table = table;
3027 st->next = curpeer->tables;
3028 if (curpeer->tables)
3029 id = curpeer->tables->local_id;
3030 st->local_id = id + 1;
3031
3032 curpeer->tables = st;
3033 }
3034
3035 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003036}
3037
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003038/*
3039 * Parse the "show peers" command arguments.
3040 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3041 * error message.
3042 */
3043static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3044{
3045 appctx->ctx.cfgpeers.target = NULL;
3046
3047 if (*args[2]) {
3048 struct peers *p;
3049
3050 for (p = cfg_peers; p; p = p->next) {
3051 if (!strcmp(p->id, args[2])) {
3052 appctx->ctx.cfgpeers.target = p;
3053 break;
3054 }
3055 }
3056
Willy Tarreau9d008692019-08-09 11:21:01 +02003057 if (!p)
3058 return cli_err(appctx, "No such peers\n");
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003059 }
3060
3061 return 0;
3062}
3063
3064/*
3065 * This function dumps the peer state information of <peers> "peers" section.
3066 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3067 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3068 */
3069static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3070{
3071 struct tm tm;
3072
3073 get_localtime(peers->last_change, &tm);
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003074 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 +02003075 peers,
3076 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3077 tm.tm_hour, tm.tm_min, tm.tm_sec,
3078 peers->id, peers->state, peers->flags,
3079 peers->resync_timeout ?
3080 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3081 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003082 TICKS_TO_MS(1000)) : "<NEVER>",
3083 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003084
3085 if (ci_putchk(si_ic(si), msg) == -1) {
3086 si_rx_room_blk(si);
3087 return 0;
3088 }
3089
3090 return 1;
3091}
3092
3093/*
3094 * This function dumps <peer> state information.
3095 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3096 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3097 */
3098static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3099{
3100 struct connection *conn;
3101 char pn[INET6_ADDRSTRLEN];
3102 struct stream_interface *peer_si;
3103 struct stream *peer_s;
3104 struct appctx *appctx;
3105 struct shared_table *st;
3106
3107 addr_to_str(&peer->addr, pn, sizeof pn);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003108 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 +02003109 peer, peer->id,
3110 peer->local ? "local" : "remote",
3111 pn, get_host_port(&peer->addr),
3112 statuscode_str(peer->statuscode),
3113 peer->reconnect ?
3114 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3115 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
3116 TICKS_TO_MS(1000)) : "<NEVER>",
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003117 peer->confirm, peer->tx_hbt, peer->rx_hbt,
3118 peer->no_hbt, peer->new_conn, peer->proto_err);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003119
3120 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3121
3122 appctx = peer->appctx;
3123 if (!appctx)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003124 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003125
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003126 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3127 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003128
3129 peer_si = peer->appctx->owner;
3130 if (!peer_si)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003131 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003132
3133 peer_s = si_strm(peer_si);
3134 if (!peer_s)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003135 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003136
3137 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3138
3139 conn = objt_conn(strm_orig(peer_s));
3140 if (conn)
3141 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3142
Willy Tarreau3ca14902019-07-17 14:53:15 +02003143 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 +02003144 case AF_INET:
3145 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003146 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(conn->src));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003147 break;
3148 case AF_UNIX:
3149 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3150 break;
3151 }
3152
Willy Tarreau3ca14902019-07-17 14:53:15 +02003153 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 +02003154 case AF_INET:
3155 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003156 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(conn->dst));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003157 break;
3158 case AF_UNIX:
3159 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3160 break;
3161 }
3162
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003163 table_info:
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003164 if (peer->remote_table)
3165 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3166 peer->remote_table,
3167 peer->remote_table->table->id,
3168 peer->remote_table->local_id,
3169 peer->remote_table->remote_id);
3170
3171 if (peer->last_local_table)
3172 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3173 peer->last_local_table,
3174 peer->last_local_table->table->id,
3175 peer->last_local_table->local_id,
3176 peer->last_local_table->remote_id);
3177
3178 if (peer->tables) {
3179 chunk_appendf(&trash, "\n shared tables:");
3180 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003181 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003182 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003183 struct dcache *dcache;
3184
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003185 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003186 dcache = peer->dcache;
3187
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003188 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3189 "flags=0x%x remote_data=0x%llx",
3190 st, st->local_id, st->remote_id,
3191 st->flags, (unsigned long long)st->remote_data);
3192 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3193 " teaching_origin=%u update=%u",
3194 st->last_acked, st->last_pushed, st->last_get,
3195 st->teaching_origin, st->update);
3196 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3197 " commitupdate=%u syncing=%u",
3198 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003199 chunk_appendf(&trash, "\n TX dictionary cache:");
3200 count = 0;
3201 for (i = 0; i < dcache->max_entries; i++) {
3202 struct ebpt_node *node;
3203 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003204
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003205 node = &dcache->tx->entries[i];
3206 if (!node->key)
3207 break;
3208
3209 if (!count++)
3210 chunk_appendf(&trash, "\n ");
3211 de = node->key;
3212 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3213 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003214 }
3215 chunk_appendf(&trash, "\n RX dictionary cache:");
3216 count = 0;
3217 for (i = 0; i < dcache->max_entries; i++) {
3218 if (!count++)
3219 chunk_appendf(&trash, "\n ");
3220 chunk_appendf(&trash, " %3u -> %s", i,
3221 dcache->rx[i].de ?
3222 (char *)dcache->rx[i].de->value.key : "-");
3223 count &= 0x3;
3224 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003225 }
3226 }
3227
3228 end:
3229 chunk_appendf(&trash, "\n");
3230 if (ci_putchk(si_ic(si), msg) == -1) {
3231 si_rx_room_blk(si);
3232 return 0;
3233 }
3234
3235 return 1;
3236}
3237
3238/*
3239 * This function dumps all the peers of "peers" section.
3240 * Returns 0 if the output buffer is full and needs to be called
3241 * again, non-zero if not. It proceeds in an isolated thread, so
3242 * there is no thread safety issue here.
3243 */
3244static int cli_io_handler_show_peers(struct appctx *appctx)
3245{
3246 int show_all;
3247 int ret = 0, first_peers = 1;
3248 struct stream_interface *si = appctx->owner;
3249
3250 thread_isolate();
3251
3252 show_all = !appctx->ctx.cfgpeers.target;
3253
3254 chunk_reset(&trash);
3255
3256 while (appctx->st2 != STAT_ST_FIN) {
3257 switch (appctx->st2) {
3258 case STAT_ST_INIT:
3259 if (show_all)
3260 appctx->ctx.cfgpeers.peers = cfg_peers;
3261 else
3262 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3263
3264 appctx->st2 = STAT_ST_LIST;
3265 /* fall through */
3266
3267 case STAT_ST_LIST:
3268 if (!appctx->ctx.cfgpeers.peers) {
3269 /* No more peers list. */
3270 appctx->st2 = STAT_ST_END;
3271 }
3272 else {
3273 if (!first_peers)
3274 chunk_appendf(&trash, "\n");
3275 else
3276 first_peers = 0;
3277 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3278 goto out;
3279
3280 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3281 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3282 appctx->st2 = STAT_ST_INFO;
3283 }
3284 break;
3285
3286 case STAT_ST_INFO:
3287 if (!appctx->ctx.cfgpeers.peer) {
3288 /* End of peer list */
3289 if (show_all)
3290 appctx->st2 = STAT_ST_LIST;
3291 else
3292 appctx->st2 = STAT_ST_END;
3293 }
3294 else {
3295 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3296 goto out;
3297
3298 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3299 }
3300 break;
3301
3302 case STAT_ST_END:
3303 appctx->st2 = STAT_ST_FIN;
3304 break;
3305 }
3306 }
3307 ret = 1;
3308 out:
3309 thread_release();
3310 return ret;
3311}
3312
3313/*
3314 * CLI keywords.
3315 */
3316static struct cli_kw_list cli_kws = {{ }, {
3317 { { "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, },
3318 {},
3319}};
3320
3321/* Register cli keywords */
3322INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3323