blob: 4d16b41a4608d81e006ac6115af209fd03cffe8f [file] [log] [blame]
Emeric Brun2b920a12010-09-23 18:30:22 +02001/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02002 * Peer synchro management.
Emeric Brun2b920a12010-09-23 18:30:22 +02003 *
4 * Copyright 2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <errno.h>
14#include <fcntl.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18
19#include <sys/socket.h>
20#include <sys/stat.h>
21#include <sys/types.h>
22
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020023#include <haproxy/api.h>
Willy Tarreau3afc4c42020-06-03 18:23:19 +020024#include <haproxy/dict.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020025#include <haproxy/net_helper.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020026#include <haproxy/time.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020027#include <haproxy/tools.h>
Willy Tarreau3f567e42020-05-28 15:29:19 +020028#include <haproxy/thread.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>
Willy Tarreau0f6ffd62020-06-03 19:33:00 +020040#include <haproxy/fd.h>
Willy Tarreaud1d48d42015-03-13 16:15:46 +010041#include <proto/frontend.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020042#include <proto/log.h>
Willy Tarreau53a47662017-08-28 10:53:00 +020043#include <proto/mux_pt.h>
Frédéric Lécaille1055e682018-04-26 14:35:21 +020044#include <proto/peers.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020045#include <proto/proxy.h>
Willy Tarreaufeb76402015-04-03 14:10:06 +020046#include <proto/session.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020047#include <proto/stream.h>
Willy Tarreau22ec1ea2014-11-27 20:45:39 +010048#include <proto/signal.h>
49#include <proto/stick_table.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020050#include <proto/stream_interface.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020051#include <proto/task.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020052
53
54/*******************************/
55/* Current peer learning state */
56/*******************************/
57
58/******************************/
Emeric Brunb3971ab2015-05-12 18:49:09 +020059/* Current peers section resync state */
Emeric Brun2b920a12010-09-23 18:30:22 +020060/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010061#define PEERS_F_RESYNC_LOCAL 0x00000001 /* Learn from local finished or no more needed */
62#define PEERS_F_RESYNC_REMOTE 0x00000002 /* Learn from remote finished or no more needed */
63#define PEERS_F_RESYNC_ASSIGN 0x00000004 /* A peer was assigned to learn our lesson */
64#define PEERS_F_RESYNC_PROCESS 0x00000008 /* The assigned peer was requested for resync */
65#define PEERS_F_DONOTSTOP 0x00010000 /* Main table sync task block process during soft stop
66 to push data to new process */
Emeric Brun2b920a12010-09-23 18:30:22 +020067
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010068#define PEERS_RESYNC_STATEMASK (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
69#define PEERS_RESYNC_FROMLOCAL 0x00000000
70#define PEERS_RESYNC_FROMREMOTE PEERS_F_RESYNC_LOCAL
71#define PEERS_RESYNC_FINISHED (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
Emeric Brunb3971ab2015-05-12 18:49:09 +020072
73/***********************************/
74/* Current shared table sync state */
75/***********************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010076#define SHTABLE_F_TEACH_STAGE1 0x00000001 /* Teach state 1 complete */
77#define SHTABLE_F_TEACH_STAGE2 0x00000002 /* Teach state 2 complete */
Emeric Brun2b920a12010-09-23 18:30:22 +020078
79/******************************/
80/* Remote peer teaching state */
81/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010082#define PEER_F_TEACH_PROCESS 0x00000001 /* Teach a lesson to current peer */
83#define PEER_F_TEACH_FINISHED 0x00000008 /* Teach conclude, (wait for confirm) */
84#define PEER_F_TEACH_COMPLETE 0x00000010 /* All that we know already taught to current peer, used only for a local peer */
85#define PEER_F_LEARN_ASSIGN 0x00000100 /* Current peer was assigned for a lesson */
86#define PEER_F_LEARN_NOTUP2DATE 0x00000200 /* Learn from peer finished but peer is not up to date */
87#define PEER_F_ALIVE 0x20000000 /* Used to flag a peer a alive. */
88#define PEER_F_HEARTBEAT 0x40000000 /* Heartbeat message to send. */
89#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 +020090
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010091#define PEER_TEACH_RESET ~(PEER_F_TEACH_PROCESS|PEER_F_TEACH_FINISHED) /* PEER_F_TEACH_COMPLETE should never be reset */
92#define PEER_LEARN_RESET ~(PEER_F_LEARN_ASSIGN|PEER_F_LEARN_NOTUP2DATE)
Emeric Brun2b920a12010-09-23 18:30:22 +020093
Frédéric Lécaille54bff832019-03-26 10:25:20 +010094#define PEER_RESYNC_TIMEOUT 5000 /* 5 seconds */
95#define PEER_RECONNECT_TIMEOUT 5000 /* 5 seconds */
Frédéric Lécaille645635d2019-02-11 17:49:39 +010096#define PEER_HEARTBEAT_TIMEOUT 3000 /* 3 seconds */
97
Emeric Brunb3971ab2015-05-12 18:49:09 +020098/*****************************/
99/* Sync message class */
100/*****************************/
101enum {
102 PEER_MSG_CLASS_CONTROL = 0,
103 PEER_MSG_CLASS_ERROR,
104 PEER_MSG_CLASS_STICKTABLE = 10,
105 PEER_MSG_CLASS_RESERVED = 255,
106};
107
108/*****************************/
109/* control message types */
110/*****************************/
111enum {
112 PEER_MSG_CTRL_RESYNCREQ = 0,
113 PEER_MSG_CTRL_RESYNCFINISHED,
114 PEER_MSG_CTRL_RESYNCPARTIAL,
115 PEER_MSG_CTRL_RESYNCCONFIRM,
Frédéric Lécaille645635d2019-02-11 17:49:39 +0100116 PEER_MSG_CTRL_HEARTBEAT,
Emeric Brunb3971ab2015-05-12 18:49:09 +0200117};
118
119/*****************************/
120/* error message types */
121/*****************************/
122enum {
123 PEER_MSG_ERR_PROTOCOL = 0,
124 PEER_MSG_ERR_SIZELIMIT,
125};
126
Emeric Brun530ba382020-06-02 11:17:42 +0200127/* network key types;
128 * network types were directly and mistakenly
129 * mapped on sample types, to keep backward
130 * compatiblitiy we keep those values but
131 * we now use a internal/network mapping
132 * to avoid further mistakes adding or
133 * modifying internals types
134 */
135enum {
136 PEER_KT_ANY = 0, /* any type */
137 PEER_KT_RESV1, /* UNUSED */
138 PEER_KT_SINT, /* signed 64bits integer type */
139 PEER_KT_RESV3, /* UNUSED */
140 PEER_KT_IPV4, /* ipv4 type */
141 PEER_KT_IPV6, /* ipv6 type */
142 PEER_KT_STR, /* char string type */
143 PEER_KT_BIN, /* buffer type */
144 PEER_KT_TYPES /* number of types, must always be last */
145};
146
147/* Map used to retrieve network type from internal type
148 * Note: Undeclared mapping maps entry to PEER_KT_ANY == 0
149 */
150static int peer_net_key_type[SMP_TYPES] = {
151 [SMP_T_SINT] = PEER_KT_SINT,
152 [SMP_T_IPV4] = PEER_KT_IPV4,
153 [SMP_T_IPV6] = PEER_KT_IPV6,
154 [SMP_T_STR] = PEER_KT_STR,
155 [SMP_T_BIN] = PEER_KT_BIN,
156};
157
158/* Map used to retrieve internal type from external type
159 * Note: Undeclared mapping maps entry to SMP_T_ANY == 0
160 */
161static int peer_int_key_type[PEER_KT_TYPES] = {
162 [PEER_KT_SINT] = SMP_T_SINT,
163 [PEER_KT_IPV4] = SMP_T_IPV4,
164 [PEER_KT_IPV6] = SMP_T_IPV6,
165 [PEER_KT_STR] = SMP_T_STR,
166 [PEER_KT_BIN] = SMP_T_BIN,
167};
168
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100169/*
170 * Parameters used by functions to build peer protocol messages. */
171struct peer_prep_params {
172 struct {
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100173 struct peer *peer;
174 } hello;
175 struct {
176 unsigned int st1;
177 } error_status;
178 struct {
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100179 struct stksess *stksess;
180 struct shared_table *shared_table;
181 unsigned int updateid;
182 int use_identifier;
183 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200184 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100185 } updt;
186 struct {
187 struct shared_table *shared_table;
188 } swtch;
189 struct {
190 struct shared_table *shared_table;
191 } ack;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100192 struct {
193 unsigned char head[2];
194 } control;
195 struct {
196 unsigned char head[2];
197 } error;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100198};
Emeric Brunb3971ab2015-05-12 18:49:09 +0200199
200/*******************************/
201/* stick table sync mesg types */
202/* Note: ids >= 128 contains */
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500203/* id message contains data */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200204/*******************************/
Olivier Houchard33992262018-10-16 18:49:26 +0200205#define PEER_MSG_STKT_UPDATE 0x80
206#define PEER_MSG_STKT_INCUPDATE 0x81
207#define PEER_MSG_STKT_DEFINE 0x82
208#define PEER_MSG_STKT_SWITCH 0x83
209#define PEER_MSG_STKT_ACK 0x84
210#define PEER_MSG_STKT_UPDATE_TIMED 0x85
211#define PEER_MSG_STKT_INCUPDATE_TIMED 0x86
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +0200212/* All the stick-table message identifiers abova have the #7 bit set */
213#define PEER_MSG_STKT_BIT 7
214#define PEER_MSG_STKT_BIT_MASK (1 << PEER_MSG_STKT_BIT)
Emeric Brun2b920a12010-09-23 18:30:22 +0200215
Frédéric Lécaille39143342019-05-24 14:32:27 +0200216/* The maximum length of an encoded data length. */
217#define PEER_MSG_ENC_LENGTH_MAXLEN 5
218
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200219/* Minimum 64-bits value encoded with 2 bytes */
220#define PEER_ENC_2BYTES_MIN 0xf0 /* 0xf0 (or 240) */
221/* 3 bytes */
222#define PEER_ENC_3BYTES_MIN ((1ULL << 11) | PEER_ENC_2BYTES_MIN) /* 0x8f0 (or 2288) */
223/* 4 bytes */
224#define PEER_ENC_4BYTES_MIN ((1ULL << 18) | PEER_ENC_3BYTES_MIN) /* 0x408f0 (or 264432) */
225/* 5 bytes */
226#define PEER_ENC_5BYTES_MIN ((1ULL << 25) | PEER_ENC_4BYTES_MIN) /* 0x20408f0 (or 33818864) */
227/* 6 bytes */
228#define PEER_ENC_6BYTES_MIN ((1ULL << 32) | PEER_ENC_5BYTES_MIN) /* 0x1020408f0 (or 4328786160) */
229/* 7 bytes */
230#define PEER_ENC_7BYTES_MIN ((1ULL << 39) | PEER_ENC_6BYTES_MIN) /* 0x81020408f0 (or 554084600048) */
231/* 8 bytes */
232#define PEER_ENC_8BYTES_MIN ((1ULL << 46) | PEER_ENC_7BYTES_MIN) /* 0x4081020408f0 (or 70922828777712) */
233/* 9 bytes */
234#define PEER_ENC_9BYTES_MIN ((1ULL << 53) | PEER_ENC_8BYTES_MIN) /* 0x204081020408f0 (or 9078122083518704) */
235/* 10 bytes */
236#define PEER_ENC_10BYTES_MIN ((1ULL << 60) | PEER_ENC_9BYTES_MIN) /* 0x10204081020408f0 (or 1161999626690365680) */
237
238/* #7 bit used to detect the last byte to be encoded */
239#define PEER_ENC_STOP_BIT 7
240/* The byte minimum value with #7 bit set */
241#define PEER_ENC_STOP_BYTE (1 << PEER_ENC_STOP_BIT)
242/* The left most number of bits set for PEER_ENC_2BYTES_MIN */
243#define PEER_ENC_2BYTES_MIN_BITS 4
244
Frédéric Lécaille39143342019-05-24 14:32:27 +0200245#define PEER_MSG_HEADER_LEN 2
246
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200247#define PEER_STKT_CACHE_MAX_ENTRIES 128
248
Emeric Brun2b920a12010-09-23 18:30:22 +0200249/**********************************/
250/* Peer Session IO handler states */
251/**********************************/
252
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100253enum {
254 PEER_SESS_ST_ACCEPT = 0, /* Initial state for session create by an accept, must be zero! */
255 PEER_SESS_ST_GETVERSION, /* Validate supported protocol version */
256 PEER_SESS_ST_GETHOST, /* Validate host ID correspond to local host id */
257 PEER_SESS_ST_GETPEER, /* Validate peer ID correspond to a known remote peer id */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100258 /* after this point, data were possibly exchanged */
259 PEER_SESS_ST_SENDSUCCESS, /* Send ret code 200 (success) and wait for message */
260 PEER_SESS_ST_CONNECT, /* Initial state for session create on a connect, push presentation into buffer */
261 PEER_SESS_ST_GETSTATUS, /* Wait for the welcome message */
262 PEER_SESS_ST_WAITMSG, /* Wait for data messages */
263 PEER_SESS_ST_EXIT, /* Exit with status code */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200264 PEER_SESS_ST_ERRPROTO, /* Send error proto message before exit */
265 PEER_SESS_ST_ERRSIZE, /* Send error size message before exit */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100266 PEER_SESS_ST_END, /* Killed session */
267};
Emeric Brun2b920a12010-09-23 18:30:22 +0200268
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100269/***************************************************/
270/* Peer Session status code - part of the protocol */
271/***************************************************/
Emeric Brun2b920a12010-09-23 18:30:22 +0200272
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100273#define PEER_SESS_SC_CONNECTCODE 100 /* connect in progress */
274#define PEER_SESS_SC_CONNECTEDCODE 110 /* tcp connect success */
Emeric Brun2b920a12010-09-23 18:30:22 +0200275
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100276#define PEER_SESS_SC_SUCCESSCODE 200 /* accept or connect successful */
Emeric Brun2b920a12010-09-23 18:30:22 +0200277
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100278#define PEER_SESS_SC_TRYAGAIN 300 /* try again later */
Emeric Brun2b920a12010-09-23 18:30:22 +0200279
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100280#define PEER_SESS_SC_ERRPROTO 501 /* error protocol */
281#define PEER_SESS_SC_ERRVERSION 502 /* unknown protocol version */
282#define PEER_SESS_SC_ERRHOST 503 /* bad host name */
283#define PEER_SESS_SC_ERRPEER 504 /* unknown peer */
Emeric Brun2b920a12010-09-23 18:30:22 +0200284
285#define PEER_SESSION_PROTO_NAME "HAProxyS"
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200286#define PEER_MAJOR_VER 2
287#define PEER_MINOR_VER 1
288#define PEER_DWNGRD_MINOR_VER 0
Emeric Brun2b920a12010-09-23 18:30:22 +0200289
Willy Tarreau6254a922019-01-29 17:45:23 +0100290static size_t proto_len = sizeof(PEER_SESSION_PROTO_NAME) - 1;
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200291struct peers *cfg_peers = NULL;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200292static void peer_session_forceshutdown(struct peer *peer);
Emeric Brun2b920a12010-09-23 18:30:22 +0200293
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200294static struct ebpt_node *dcache_tx_insert(struct dcache *dc,
295 struct dcache_tx_entry *i);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200296static inline void flush_dcache(struct peer *peer);
297
Frédéric Lécaille95679dc2019-04-15 10:25:27 +0200298static const char *statuscode_str(int statuscode)
299{
300 switch (statuscode) {
301 case PEER_SESS_SC_CONNECTCODE:
302 return "CONN";
303 case PEER_SESS_SC_CONNECTEDCODE:
304 return "HSHK";
305 case PEER_SESS_SC_SUCCESSCODE:
306 return "ESTA";
307 case PEER_SESS_SC_TRYAGAIN:
308 return "RETR";
309 case PEER_SESS_SC_ERRPROTO:
310 return "PROT";
311 case PEER_SESS_SC_ERRVERSION:
312 return "VERS";
313 case PEER_SESS_SC_ERRHOST:
314 return "NAME";
315 case PEER_SESS_SC_ERRPEER:
316 return "UNKN";
317 default:
318 return "NONE";
319 }
320}
321
Emeric Brun18928af2017-03-29 16:32:53 +0200322/* This function encode an uint64 to 'dynamic' length format.
323 The encoded value is written at address *str, and the
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500324 caller must assure that size after *str is large enough.
Emeric Brun18928af2017-03-29 16:32:53 +0200325 At return, the *str is set at the next Byte after then
326 encoded integer. The function returns then length of the
327 encoded integer in Bytes */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200328int intencode(uint64_t i, char **str) {
329 int idx = 0;
330 unsigned char *msg;
331
Emeric Brunb3971ab2015-05-12 18:49:09 +0200332 msg = (unsigned char *)*str;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200333 if (i < PEER_ENC_2BYTES_MIN) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200334 msg[0] = (unsigned char)i;
335 *str = (char *)&msg[idx+1];
336 return (idx+1);
337 }
338
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200339 msg[idx] =(unsigned char)i | PEER_ENC_2BYTES_MIN;
340 i = (i - PEER_ENC_2BYTES_MIN) >> PEER_ENC_2BYTES_MIN_BITS;
341 while (i >= PEER_ENC_STOP_BYTE) {
342 msg[++idx] = (unsigned char)i | PEER_ENC_STOP_BYTE;
343 i = (i - PEER_ENC_STOP_BYTE) >> PEER_ENC_STOP_BIT;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200344 }
345 msg[++idx] = (unsigned char)i;
346 *str = (char *)&msg[idx+1];
347 return (idx+1);
348}
349
350
351/* This function returns the decoded integer or 0
352 if decode failed
353 *str point on the beginning of the integer to decode
354 at the end of decoding *str point on the end of the
355 encoded integer or to null if end is reached */
Emeric Brun18928af2017-03-29 16:32:53 +0200356uint64_t intdecode(char **str, char *end)
357{
Emeric Brunb3971ab2015-05-12 18:49:09 +0200358 unsigned char *msg;
Emeric Brun18928af2017-03-29 16:32:53 +0200359 uint64_t i;
360 int shift;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200361
362 if (!*str)
363 return 0;
364
365 msg = (unsigned char *)*str;
Emeric Brun18928af2017-03-29 16:32:53 +0200366 if (msg >= (unsigned char *)end)
367 goto fail;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200368
Emeric Brun18928af2017-03-29 16:32:53 +0200369 i = *(msg++);
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200370 if (i >= PEER_ENC_2BYTES_MIN) {
371 shift = PEER_ENC_2BYTES_MIN_BITS;
Emeric Brun18928af2017-03-29 16:32:53 +0200372 do {
373 if (msg >= (unsigned char *)end)
374 goto fail;
375 i += (uint64_t)*msg << shift;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200376 shift += PEER_ENC_STOP_BIT;
377 } while (*(msg++) >= PEER_ENC_STOP_BYTE);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200378 }
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100379 *str = (char *)msg;
380 return i;
Emeric Brun18928af2017-03-29 16:32:53 +0200381
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100382 fail:
383 *str = NULL;
384 return 0;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200385}
Emeric Brun2b920a12010-09-23 18:30:22 +0200386
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100387/*
388 * Build a "hello" peer protocol message.
389 * Return the number of written bytes written to build this messages if succeeded,
390 * 0 if not.
391 */
392static int peer_prepare_hellomsg(char *msg, size_t size, struct peer_prep_params *p)
393{
394 int min_ver, ret;
395 struct peer *peer;
396
397 peer = p->hello.peer;
398 min_ver = (peer->flags & PEER_F_DWNGRD) ? PEER_DWNGRD_MINOR_VER : PEER_MINOR_VER;
399 /* Prepare headers */
400 ret = snprintf(msg, size, PEER_SESSION_PROTO_NAME " %u.%u\n%s\n%s %d %d\n",
401 PEER_MAJOR_VER, min_ver, peer->id, localpeer, (int)getpid(), relative_pid);
402 if (ret >= size)
403 return 0;
404
405 return ret;
406}
407
408/*
409 * Build a "handshake succeeded" status message.
410 * Return the number of written bytes written to build this messages if succeeded,
411 * 0 if not.
412 */
413static int peer_prepare_status_successmsg(char *msg, size_t size, struct peer_prep_params *p)
414{
415 int ret;
416
417 ret = snprintf(msg, size, "%d\n", PEER_SESS_SC_SUCCESSCODE);
418 if (ret >= size)
419 return 0;
420
421 return ret;
422}
423
424/*
425 * Build an error status message.
426 * Return the number of written bytes written to build this messages if succeeded,
427 * 0 if not.
428 */
429static int peer_prepare_status_errormsg(char *msg, size_t size, struct peer_prep_params *p)
430{
431 int ret;
432 unsigned int st1;
433
434 st1 = p->error_status.st1;
435 ret = snprintf(msg, size, "%d\n", st1);
436 if (ret >= size)
437 return 0;
438
439 return ret;
440}
441
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200442/* Set the stick-table UPDATE message type byte at <msg_type> address,
443 * depending on <use_identifier> and <use_timed> boolean parameters.
444 * Always successful.
445 */
446static inline void peer_set_update_msg_type(char *msg_type, int use_identifier, int use_timed)
447{
448 if (use_timed) {
449 if (use_identifier)
450 *msg_type = PEER_MSG_STKT_UPDATE_TIMED;
451 else
452 *msg_type = PEER_MSG_STKT_INCUPDATE_TIMED;
453 }
454 else {
455 if (use_identifier)
456 *msg_type = PEER_MSG_STKT_UPDATE;
457 else
458 *msg_type = PEER_MSG_STKT_INCUPDATE;
459 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200460}
Emeric Brun2b920a12010-09-23 18:30:22 +0200461/*
Emeric Brunb3971ab2015-05-12 18:49:09 +0200462 * This prepare the data update message on the stick session <ts>, <st> is the considered
463 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800464 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200465 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
466 * check size)
Emeric Brun2b920a12010-09-23 18:30:22 +0200467 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100468static int peer_prepare_updatemsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brun2b920a12010-09-23 18:30:22 +0200469{
470 uint32_t netinteger;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200471 unsigned short datalen;
472 char *cursor, *datamsg;
Emeric Brun94900952015-06-11 18:25:54 +0200473 unsigned int data_type;
474 void *data_ptr;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100475 struct stksess *ts;
476 struct shared_table *st;
477 unsigned int updateid;
478 int use_identifier;
479 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200480 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100481
482 ts = p->updt.stksess;
483 st = p->updt.shared_table;
484 updateid = p->updt.updateid;
485 use_identifier = p->updt.use_identifier;
486 use_timed = p->updt.use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200487 peer = p->updt.peer;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200488
Frédéric Lécaille0e8db972019-05-24 14:34:34 +0200489 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200490
Emeric Brun2b920a12010-09-23 18:30:22 +0200491 /* construct message */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200492
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500493 /* check if we need to send the update identifier */
Emeric Brun819fc6f2017-06-13 19:37:32 +0200494 if (!st->last_pushed || updateid < st->last_pushed || ((updateid - st->last_pushed) != 1)) {
Emeric Bruna6a09982015-09-22 15:34:19 +0200495 use_identifier = 1;
Emeric Brun2b920a12010-09-23 18:30:22 +0200496 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200497
498 /* encode update identifier if needed */
499 if (use_identifier) {
Emeric Brun819fc6f2017-06-13 19:37:32 +0200500 netinteger = htonl(updateid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200501 memcpy(cursor, &netinteger, sizeof(netinteger));
502 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200503 }
504
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200505 if (use_timed) {
506 netinteger = htonl(tick_remain(now_ms, ts->expire));
507 memcpy(cursor, &netinteger, sizeof(netinteger));
508 cursor += sizeof(netinteger);
509 }
510
Emeric Brunb3971ab2015-05-12 18:49:09 +0200511 /* encode the key */
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200512 if (st->table->type == SMP_T_STR) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200513 int stlen = strlen((char *)ts->key.key);
514
Emeric Brunb3971ab2015-05-12 18:49:09 +0200515 intencode(stlen, &cursor);
516 memcpy(cursor, ts->key.key, stlen);
517 cursor += stlen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200518 }
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200519 else if (st->table->type == SMP_T_SINT) {
Willy Tarreau6cde5d82020-02-25 09:41:22 +0100520 netinteger = htonl(read_u32(ts->key.key));
Emeric Brunb3971ab2015-05-12 18:49:09 +0200521 memcpy(cursor, &netinteger, sizeof(netinteger));
522 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200523 }
524 else {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200525 memcpy(cursor, ts->key.key, st->table->key_size);
526 cursor += st->table->key_size;
Emeric Brun2b920a12010-09-23 18:30:22 +0200527 }
528
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100529 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200530 /* encode values */
Emeric Brun94900952015-06-11 18:25:54 +0200531 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200532
Emeric Brun94900952015-06-11 18:25:54 +0200533 data_ptr = stktable_data_ptr(st->table, ts, data_type);
534 if (data_ptr) {
535 switch (stktable_data_types[data_type].std_type) {
536 case STD_T_SINT: {
537 int data;
538
539 data = stktable_data_cast(data_ptr, std_t_sint);
540 intencode(data, &cursor);
541 break;
542 }
543 case STD_T_UINT: {
544 unsigned int data;
545
546 data = stktable_data_cast(data_ptr, std_t_uint);
547 intencode(data, &cursor);
548 break;
549 }
550 case STD_T_ULL: {
551 unsigned long long data;
552
553 data = stktable_data_cast(data_ptr, std_t_ull);
554 intencode(data, &cursor);
555 break;
556 }
557 case STD_T_FRQP: {
558 struct freq_ctr_period *frqp;
559
560 frqp = &stktable_data_cast(data_ptr, std_t_frqp);
561 intencode((unsigned int)(now_ms - frqp->curr_tick), &cursor);
562 intencode(frqp->curr_ctr, &cursor);
563 intencode(frqp->prev_ctr, &cursor);
564 break;
565 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200566 case STD_T_DICT: {
567 struct dict_entry *de;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200568 struct ebpt_node *cached_de;
Willy Tarreau237f8ae2019-06-06 16:40:43 +0200569 struct dcache_tx_entry cde = { };
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200570 char *beg, *end;
571 size_t value_len, data_len;
572 struct dcache *dc;
573
574 de = stktable_data_cast(data_ptr, std_t_dict);
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100575 if (!de) {
576 /* No entry */
577 intencode(0, &cursor);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200578 break;
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100579 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200580
581 dc = peer->dcache;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200582 cde.entry.key = de;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200583 cached_de = dcache_tx_insert(dc, &cde);
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200584 if (cached_de == &cde.entry) {
585 if (cde.id + 1 >= PEER_ENC_2BYTES_MIN)
586 break;
587 /* Encode the length of the remaining data -> 1 */
588 intencode(1, &cursor);
589 /* Encode the cache entry ID */
590 intencode(cde.id + 1, &cursor);
591 }
592 else {
593 /* Leave enough room to encode the remaining data length. */
594 end = beg = cursor + PEER_MSG_ENC_LENGTH_MAXLEN;
595 /* Encode the dictionary entry key */
596 intencode(cde.id + 1, &end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200597 /* Encode the length of the dictionary entry data */
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200598 value_len = de->len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200599 intencode(value_len, &end);
600 /* Copy the data */
601 memcpy(end, de->value.key, value_len);
602 end += value_len;
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200603 /* Encode the length of the data */
604 data_len = end - beg;
605 intencode(data_len, &cursor);
606 memmove(cursor, beg, data_len);
607 cursor += data_len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200608 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200609 break;
610 }
Emeric Brun94900952015-06-11 18:25:54 +0200611 }
612 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200613 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100614 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200615
616 /* Compute datalen */
617 datalen = (cursor - datamsg);
618
619 /* prepare message header */
620 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200621 peer_set_update_msg_type(&msg[1], use_identifier, use_timed);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200622 cursor = &msg[2];
623 intencode(datalen, &cursor);
624
625 /* move data after header */
626 memmove(cursor, datamsg, datalen);
627
628 /* return header size + data_len */
629 return (cursor - msg) + datalen;
630}
631
632/*
633 * This prepare the switch table message to targeted share table <st>.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800634 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200635 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
636 * check size)
637 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100638static int peer_prepare_switchmsg(char *msg, size_t size, struct peer_prep_params *params)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200639{
640 int len;
641 unsigned short datalen;
Willy Tarreau83061a82018-07-13 11:56:34 +0200642 struct buffer *chunk;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200643 char *cursor, *datamsg, *chunkp, *chunkq;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200644 uint64_t data = 0;
Emeric Brun94900952015-06-11 18:25:54 +0200645 unsigned int data_type;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100646 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200647
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100648 st = params->swtch.shared_table;
Frédéric Lécaille39143342019-05-24 14:32:27 +0200649 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200650
651 /* Encode data */
652
653 /* encode local id */
654 intencode(st->local_id, &cursor);
655
656 /* encode table name */
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100657 len = strlen(st->table->nid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200658 intencode(len, &cursor);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100659 memcpy(cursor, st->table->nid, len);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200660 cursor += len;
661
662 /* encode table type */
663
Emeric Brun530ba382020-06-02 11:17:42 +0200664 intencode(peer_net_key_type[st->table->type], &cursor);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200665
666 /* encode table key size */
667 intencode(st->table->key_size, &cursor);
668
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200669 chunk = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200670 chunkp = chunkq = chunk->area;
Emeric Brun94900952015-06-11 18:25:54 +0200671 /* encode available known data types in table */
672 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
673 if (st->table->data_ofs[data_type]) {
674 switch (stktable_data_types[data_type].std_type) {
675 case STD_T_SINT:
676 case STD_T_UINT:
677 case STD_T_ULL:
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200678 case STD_T_DICT:
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200679 data |= 1 << data_type;
680 break;
Emeric Brun94900952015-06-11 18:25:54 +0200681 case STD_T_FRQP:
682 data |= 1 << data_type;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200683 intencode(data_type, &chunkq);
684 intencode(st->table->data_arg[data_type].u, &chunkq);
Emeric Brun94900952015-06-11 18:25:54 +0200685 break;
686 }
687 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200688 }
689 intencode(data, &cursor);
690
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200691 /* Encode stick-table entries duration. */
692 intencode(st->table->expire, &cursor);
693
694 if (chunkq > chunkp) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200695 chunk->data = chunkq - chunkp;
696 memcpy(cursor, chunk->area, chunk->data);
697 cursor += chunk->data;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200698 }
699
Emeric Brunb3971ab2015-05-12 18:49:09 +0200700 /* Compute datalen */
701 datalen = (cursor - datamsg);
Emeric Brun2b920a12010-09-23 18:30:22 +0200702
Emeric Brunb3971ab2015-05-12 18:49:09 +0200703 /* prepare message header */
704 msg[0] = PEER_MSG_CLASS_STICKTABLE;
705 msg[1] = PEER_MSG_STKT_DEFINE;
706 cursor = &msg[2];
707 intencode(datalen, &cursor);
Emeric Brun2b920a12010-09-23 18:30:22 +0200708
Emeric Brunb3971ab2015-05-12 18:49:09 +0200709 /* move data after header */
710 memmove(cursor, datamsg, datalen);
711
712 /* return header size + data_len */
713 return (cursor - msg) + datalen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200714}
715
Emeric Brunb3971ab2015-05-12 18:49:09 +0200716/*
717 * This prepare the acknowledge message on the stick session <ts>, <st> is the considered
718 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800719 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200720 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
721 * check size)
722 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100723static int peer_prepare_ackmsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200724{
725 unsigned short datalen;
726 char *cursor, *datamsg;
727 uint32_t netinteger;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100728 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200729
Frédéric Lécaille39143342019-05-24 14:32:27 +0200730 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200731
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100732 st = p->ack.shared_table;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200733 intencode(st->remote_id, &cursor);
734 netinteger = htonl(st->last_get);
735 memcpy(cursor, &netinteger, sizeof(netinteger));
736 cursor += sizeof(netinteger);
737
738 /* Compute datalen */
739 datalen = (cursor - datamsg);
740
741 /* prepare message header */
742 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Emeric Brune1ab8082015-08-21 11:48:54 +0200743 msg[1] = PEER_MSG_STKT_ACK;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200744 cursor = &msg[2];
745 intencode(datalen, &cursor);
746
747 /* move data after header */
748 memmove(cursor, datamsg, datalen);
749
750 /* return header size + data_len */
751 return (cursor - msg) + datalen;
752}
Emeric Brun2b920a12010-09-23 18:30:22 +0200753
754/*
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200755 * Function to deinit connected peer
756 */
757void __peer_session_deinit(struct peer *peer)
758{
759 struct stream_interface *si;
760 struct stream *s;
761 struct peers *peers;
762
763 if (!peer->appctx)
764 return;
765
766 si = peer->appctx->owner;
767 if (!si)
768 return;
769
770 s = si_strm(si);
771 if (!s)
772 return;
773
774 peers = strm_fe(s)->parent;
775 if (!peers)
776 return;
777
778 if (peer->appctx->st0 == PEER_SESS_ST_WAITMSG)
779 HA_ATOMIC_SUB(&connected_peers, 1);
780
781 HA_ATOMIC_SUB(&active_peers, 1);
782
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200783 flush_dcache(peer);
784
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200785 /* Re-init current table pointers to force announcement on re-connect */
786 peer->remote_table = peer->last_local_table = NULL;
787 peer->appctx = NULL;
788 if (peer->flags & PEER_F_LEARN_ASSIGN) {
789 /* unassign current peer for learning */
790 peer->flags &= ~(PEER_F_LEARN_ASSIGN);
791 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
792
793 /* reschedule a resync */
794 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
795 }
796 /* reset teaching and learning flags to 0 */
797 peer->flags &= PEER_TEACH_RESET;
798 peer->flags &= PEER_LEARN_RESET;
Frédéric Lécaille3585cab2019-11-20 11:17:30 +0100799 /* set this peer as dead from heartbeat point of view */
800 peer->flags &= ~PEER_F_ALIVE;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200801 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
802}
803
804/*
Emeric Brun2b920a12010-09-23 18:30:22 +0200805 * Callback to release a session with a peer
806 */
Willy Tarreau00a37f02015-04-13 12:05:19 +0200807static void peer_session_release(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +0200808{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200809 struct peer *peer = appctx->ctx.peers.ptr;
Emeric Brun2b920a12010-09-23 18:30:22 +0200810
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100811 /* appctx->ctx.peers.ptr is not a peer session */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100812 if (appctx->st0 < PEER_SESS_ST_SENDSUCCESS)
Emeric Brun2b920a12010-09-23 18:30:22 +0200813 return;
814
815 /* peer session identified */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200816 if (peer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100817 HA_SPIN_LOCK(PEER_LOCK, &peer->lock);
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200818 if (peer->appctx == appctx)
819 __peer_session_deinit(peer);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100820 HA_SPIN_UNLOCK(PEER_LOCK, &peer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +0200821 }
822}
823
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200824/* Retrieve the major and minor versions of peers protocol
825 * announced by a remote peer. <str> is a null-terminated
826 * string with the following format: "<maj_ver>.<min_ver>".
827 */
828static int peer_get_version(const char *str,
829 unsigned int *maj_ver, unsigned int *min_ver)
830{
831 unsigned int majv, minv;
832 const char *pos, *saved;
833 const char *end;
834
835 saved = pos = str;
836 end = str + strlen(str);
837
838 majv = read_uint(&pos, end);
839 if (saved == pos || *pos++ != '.')
840 return -1;
841
842 saved = pos;
843 minv = read_uint(&pos, end);
844 if (saved == pos || pos != end)
845 return -1;
846
847 *maj_ver = majv;
848 *min_ver = minv;
849
850 return 0;
851}
Emeric Brun2b920a12010-09-23 18:30:22 +0200852
853/*
Frédéric Lécaillece025572019-01-21 13:38:06 +0100854 * Parse a line terminated by an optional '\r' character, followed by a mandatory
855 * '\n' character.
856 * Returns 1 if succeeded or 0 if a '\n' character could not be found, and -1 if
857 * a line could not be read because the communication channel is closed.
858 */
859static inline int peer_getline(struct appctx *appctx)
860{
861 int n;
862 struct stream_interface *si = appctx->owner;
863
864 n = co_getline(si_oc(si), trash.area, trash.size);
865 if (!n)
866 return 0;
867
868 if (n < 0 || trash.area[n - 1] != '\n') {
869 appctx->st0 = PEER_SESS_ST_END;
870 return -1;
871 }
872
873 if (n > 1 && (trash.area[n - 2] == '\r'))
874 trash.area[n - 2] = 0;
875 else
876 trash.area[n - 1] = 0;
877
878 co_skip(si_oc(si), n);
879
880 return n;
881}
882
883/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100884 * Send a message after having called <peer_prepare_msg> to build it.
885 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
886 * Returns -1 if there was not enough room left to send the message,
887 * any other negative returned value must be considered as an error with an appcxt st0
888 * returned value equal to PEER_SESS_ST_END.
889 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100890static inline int peer_send_msg(struct appctx *appctx,
891 int (*peer_prepare_msg)(char *, size_t, struct peer_prep_params *),
892 struct peer_prep_params *params)
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100893{
894 int ret, msglen;
895 struct stream_interface *si = appctx->owner;
896
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100897 msglen = peer_prepare_msg(trash.area, trash.size, params);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100898 if (!msglen) {
899 /* internal error: message does not fit in trash */
900 appctx->st0 = PEER_SESS_ST_END;
901 return 0;
902 }
903
904 /* message to buffer */
905 ret = ci_putblk(si_ic(si), trash.area, msglen);
906 if (ret <= 0) {
907 if (ret == -1) {
908 /* No more write possible */
909 si_rx_room_blk(si);
910 return -1;
911 }
912 appctx->st0 = PEER_SESS_ST_END;
913 }
914
915 return ret;
916}
917
918/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100919 * Send a hello message.
920 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
921 * Returns -1 if there was not enough room left to send the message,
922 * any other negative returned value must be considered as an error with an appcxt st0
923 * returned value equal to PEER_SESS_ST_END.
924 */
925static inline int peer_send_hellomsg(struct appctx *appctx, struct peer *peer)
926{
927 struct peer_prep_params p = {
928 .hello.peer = peer,
929 };
930
931 return peer_send_msg(appctx, peer_prepare_hellomsg, &p);
932}
933
934/*
935 * Send a success peer handshake status message.
936 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
937 * Returns -1 if there was not enough room left to send the message,
938 * any other negative returned value must be considered as an error with an appcxt st0
939 * returned value equal to PEER_SESS_ST_END.
940 */
941static inline int peer_send_status_successmsg(struct appctx *appctx)
942{
943 return peer_send_msg(appctx, peer_prepare_status_successmsg, NULL);
944}
945
946/*
947 * Send a peer handshake status error message.
948 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
949 * Returns -1 if there was not enough room left to send the message,
950 * any other negative returned value must be considered as an error with an appcxt st0
951 * returned value equal to PEER_SESS_ST_END.
952 */
953static inline int peer_send_status_errormsg(struct appctx *appctx)
954{
955 struct peer_prep_params p = {
956 .error_status.st1 = appctx->st1,
957 };
958
959 return peer_send_msg(appctx, peer_prepare_status_errormsg, &p);
960}
961
962/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100963 * Send a stick-table switch message.
964 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
965 * Returns -1 if there was not enough room left to send the message,
966 * any other negative returned value must be considered as an error with an appcxt st0
967 * returned value equal to PEER_SESS_ST_END.
968 */
969static inline int peer_send_switchmsg(struct shared_table *st, struct appctx *appctx)
970{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100971 struct peer_prep_params p = {
972 .swtch.shared_table = st,
973 };
974
975 return peer_send_msg(appctx, peer_prepare_switchmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100976}
977
978/*
979 * Send a stick-table update acknowledgement message.
980 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
981 * Returns -1 if there was not enough room left to send the message,
982 * any other negative returned value must be considered as an error with an appcxt st0
983 * returned value equal to PEER_SESS_ST_END.
984 */
985static inline int peer_send_ackmsg(struct shared_table *st, struct appctx *appctx)
986{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100987 struct peer_prep_params p = {
988 .ack.shared_table = st,
989 };
990
991 return peer_send_msg(appctx, peer_prepare_ackmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100992}
993
994/*
Frédéric Lécaille87f554c2019-01-22 17:26:50 +0100995 * Send a stick-table update message.
996 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
997 * Returns -1 if there was not enough room left to send the message,
998 * any other negative returned value must be considered as an error with an appcxt st0
999 * returned value equal to PEER_SESS_ST_END.
1000 */
1001static inline int peer_send_updatemsg(struct shared_table *st, struct appctx *appctx, struct stksess *ts,
1002 unsigned int updateid, int use_identifier, int use_timed)
1003{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001004 struct peer_prep_params p = {
1005 .updt.stksess = ts,
1006 .updt.shared_table = st,
1007 .updt.updateid = updateid,
1008 .updt.use_identifier = use_identifier,
1009 .updt.use_timed = use_timed,
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001010 .updt.peer = appctx->ctx.peers.ptr,
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001011 };
1012
1013 return peer_send_msg(appctx, peer_prepare_updatemsg, &p);
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001014}
1015
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001016/*
1017 * Build a peer protocol control class message.
1018 * Returns the number of written bytes used to build the message if succeeded,
1019 * 0 if not.
1020 */
1021static int peer_prepare_control_msg(char *msg, size_t size, struct peer_prep_params *p)
1022{
1023 if (size < sizeof p->control.head)
1024 return 0;
1025
1026 msg[0] = p->control.head[0];
1027 msg[1] = p->control.head[1];
1028
1029 return 2;
1030}
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001031
1032/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001033 * Send a stick-table synchronization request message.
1034 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1035 * Returns -1 if there was not enough room left to send the message,
1036 * any other negative returned value must be considered as an error with an appctx st0
1037 * returned value equal to PEER_SESS_ST_END.
1038 */
1039static inline int peer_send_resync_reqmsg(struct appctx *appctx)
1040{
1041 struct peer_prep_params p = {
1042 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCREQ, },
1043 };
1044
1045 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1046}
1047
1048/*
1049 * Send a stick-table synchronization confirmation message.
1050 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1051 * Returns -1 if there was not enough room left to send the message,
1052 * any other negative returned value must be considered as an error with an appctx st0
1053 * returned value equal to PEER_SESS_ST_END.
1054 */
1055static inline int peer_send_resync_confirmsg(struct appctx *appctx)
1056{
1057 struct peer_prep_params p = {
1058 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCCONFIRM, },
1059 };
1060
1061 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1062}
1063
1064/*
1065 * Send a stick-table synchronization finished message.
1066 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1067 * Returns -1 if there was not enough room left to send the message,
1068 * any other negative returned value must be considered as an error with an appctx st0
1069 * returned value equal to PEER_SESS_ST_END.
1070 */
Emeric Brun70de43b2020-03-16 10:51:01 +01001071static inline int peer_send_resync_finishedmsg(struct appctx *appctx, struct peers *peers)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001072{
1073 struct peer_prep_params p = {
1074 .control.head = { PEER_MSG_CLASS_CONTROL, },
1075 };
1076
Emeric Brun70de43b2020-03-16 10:51:01 +01001077 p.control.head[1] = (peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED ?
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001078 PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
1079
1080 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1081}
1082
1083/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001084 * Send a heartbeat message.
1085 * Return 0 if the message could not be built modifying the appctx st0 to PEER_SESS_ST_END value.
1086 * Returns -1 if there was not enough room left to send the message,
1087 * any other negative returned value must be considered as an error with an appctx st0
1088 * returned value equal to PEER_SESS_ST_END.
1089 */
1090static inline int peer_send_heartbeatmsg(struct appctx *appctx)
1091{
1092 struct peer_prep_params p = {
1093 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_HEARTBEAT, },
1094 };
1095
1096 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1097}
1098
1099/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001100 * Build a peer protocol error class message.
1101 * Returns the number of written bytes used to build the message if succeeded,
1102 * 0 if not.
1103 */
1104static int peer_prepare_error_msg(char *msg, size_t size, struct peer_prep_params *p)
1105{
1106 if (size < sizeof p->error.head)
1107 return 0;
1108
1109 msg[0] = p->error.head[0];
1110 msg[1] = p->error.head[1];
1111
1112 return 2;
1113}
1114
1115/*
1116 * Send a "size limit reached" error message.
1117 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1118 * Returns -1 if there was not enough room left to send the message,
1119 * any other negative returned value must be considered as an error with an appctx st0
1120 * returned value equal to PEER_SESS_ST_END.
1121 */
1122static inline int peer_send_error_size_limitmsg(struct appctx *appctx)
1123{
1124 struct peer_prep_params p = {
1125 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_SIZELIMIT, },
1126 };
1127
1128 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1129}
1130
1131/*
1132 * Send a "peer protocol" error message.
1133 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1134 * Returns -1 if there was not enough room left to send the message,
1135 * any other negative returned value must be considered as an error with an appctx st0
1136 * returned value equal to PEER_SESS_ST_END.
1137 */
1138static inline int peer_send_error_protomsg(struct appctx *appctx)
1139{
1140 struct peer_prep_params p = {
1141 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_PROTOCOL, },
1142 };
1143
1144 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1145}
1146
1147/*
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001148 * Function used to lookup for recent stick-table updates associated with
1149 * <st> shared stick-table when a lesson must be taught a peer (PEER_F_LEARN_ASSIGN flag set).
1150 */
1151static inline struct stksess *peer_teach_process_stksess_lookup(struct shared_table *st)
1152{
1153 struct eb32_node *eb;
1154
1155 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1156 if (!eb) {
1157 eb = eb32_first(&st->table->updates);
1158 if (!eb || ((int)(eb->key - st->last_pushed) <= 0)) {
1159 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1160 return NULL;
1161 }
1162 }
1163
1164 if ((int)(eb->key - st->table->localupdate) > 0) {
1165 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1166 return NULL;
1167 }
1168
1169 return eb32_entry(eb, struct stksess, upd);
1170}
1171
1172/*
1173 * Function used to lookup for recent stick-table updates associated with
1174 * <st> shared stick-table during teach state 1 step.
1175 */
1176static inline struct stksess *peer_teach_stage1_stksess_lookup(struct shared_table *st)
1177{
1178 struct eb32_node *eb;
1179
1180 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1181 if (!eb) {
1182 st->flags |= SHTABLE_F_TEACH_STAGE1;
1183 eb = eb32_first(&st->table->updates);
1184 if (eb)
1185 st->last_pushed = eb->key - 1;
1186 return NULL;
1187 }
1188
1189 return eb32_entry(eb, struct stksess, upd);
1190}
1191
1192/*
1193 * Function used to lookup for recent stick-table updates associated with
1194 * <st> shared stick-table during teach state 2 step.
1195 */
1196static inline struct stksess *peer_teach_stage2_stksess_lookup(struct shared_table *st)
1197{
1198 struct eb32_node *eb;
1199
1200 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1201 if (!eb || eb->key > st->teaching_origin) {
1202 st->flags |= SHTABLE_F_TEACH_STAGE2;
1203 return NULL;
1204 }
1205
1206 return eb32_entry(eb, struct stksess, upd);
1207}
1208
1209/*
1210 * Generic function to emit update messages for <st> stick-table when a lesson must
1211 * be taught to the peer <p>.
1212 * <locked> must be set to 1 if the shared table <st> is already locked when entering
1213 * this function, 0 if not.
1214 *
1215 * This function temporary unlock/lock <st> when it sends stick-table updates or
1216 * when decrementing its refcount in case of any error when it sends this updates.
1217 *
1218 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1219 * Returns -1 if there was not enough room left to send the message,
1220 * any other negative returned value must be considered as an error with an appcxt st0
1221 * returned value equal to PEER_SESS_ST_END.
1222 * If it returns 0 or -1, this function leave <st> locked if already locked when entering this function
1223 * unlocked if not already locked when entering this function.
1224 */
1225static inline int peer_send_teachmsgs(struct appctx *appctx, struct peer *p,
1226 struct stksess *(*peer_stksess_lookup)(struct shared_table *),
1227 struct shared_table *st, int locked)
1228{
1229 int ret, new_pushed, use_timed;
1230
1231 ret = 1;
1232 use_timed = 0;
1233 if (st != p->last_local_table) {
1234 ret = peer_send_switchmsg(st, appctx);
1235 if (ret <= 0)
1236 return ret;
1237
1238 p->last_local_table = st;
1239 }
1240
1241 if (peer_stksess_lookup != peer_teach_process_stksess_lookup)
1242 use_timed = !(p->flags & PEER_F_DWNGRD);
1243
1244 /* We force new pushed to 1 to force identifier in update message */
1245 new_pushed = 1;
1246
1247 if (!locked)
1248 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1249
1250 while (1) {
1251 struct stksess *ts;
1252 unsigned updateid;
1253
1254 /* push local updates */
1255 ts = peer_stksess_lookup(st);
1256 if (!ts)
1257 break;
1258
1259 updateid = ts->upd.key;
1260 ts->ref_cnt++;
1261 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1262
1263 ret = peer_send_updatemsg(st, appctx, ts, updateid, new_pushed, use_timed);
1264 if (ret <= 0) {
1265 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1266 ts->ref_cnt--;
1267 if (!locked)
1268 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1269 return ret;
1270 }
1271
1272 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1273 ts->ref_cnt--;
1274 st->last_pushed = updateid;
1275
1276 if (peer_stksess_lookup == peer_teach_process_stksess_lookup &&
1277 (int)(st->last_pushed - st->table->commitupdate) > 0)
1278 st->table->commitupdate = st->last_pushed;
1279
1280 /* identifier may not needed in next update message */
1281 new_pushed = 0;
1282 }
1283
1284 out:
1285 if (!locked)
1286 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1287 return 1;
1288}
1289
1290/*
1291 * Function to emit update messages for <st> stick-table when a lesson must
1292 * be taught to the peer <p> (PEER_F_LEARN_ASSIGN flag set).
1293 *
1294 * Note that <st> shared stick-table is locked when calling this function.
1295 *
1296 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1297 * Returns -1 if there was not enough room left to send the message,
1298 * any other negative returned value must be considered as an error with an appcxt st0
1299 * returned value equal to PEER_SESS_ST_END.
1300 */
1301static inline int peer_send_teach_process_msgs(struct appctx *appctx, struct peer *p,
1302 struct shared_table *st)
1303{
1304 return peer_send_teachmsgs(appctx, p, peer_teach_process_stksess_lookup, st, 1);
1305}
1306
1307/*
1308 * Function to emit update messages for <st> stick-table when a lesson must
1309 * be taught to the peer <p> during teach state 1 step.
1310 *
1311 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1312 * Returns -1 if there was not enough room left to send the message,
1313 * any other negative returned value must be considered as an error with an appcxt st0
1314 * returned value equal to PEER_SESS_ST_END.
1315 */
1316static inline int peer_send_teach_stage1_msgs(struct appctx *appctx, struct peer *p,
1317 struct shared_table *st)
1318{
1319 return peer_send_teachmsgs(appctx, p, peer_teach_stage1_stksess_lookup, st, 0);
1320}
1321
1322/*
1323 * Function to emit update messages for <st> stick-table when a lesson must
1324 * be taught to the peer <p> during teach state 1 step.
1325 *
1326 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1327 * Returns -1 if there was not enough room left to send the message,
1328 * any other negative returned value must be considered as an error with an appcxt st0
1329 * returned value equal to PEER_SESS_ST_END.
1330 */
1331static inline int peer_send_teach_stage2_msgs(struct appctx *appctx, struct peer *p,
1332 struct shared_table *st)
1333{
1334 return peer_send_teachmsgs(appctx, p, peer_teach_stage2_stksess_lookup, st, 0);
1335}
1336
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001337
1338/*
1339 * Function used to parse a stick-table update message after it has been received
1340 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1341 * receipt buffer with <msg_end> being position of the end of the stick-table message.
1342 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1343 * was encountered.
1344 * <exp> must be set if the stick-table entry expires.
1345 * <updt> must be set for PEER_MSG_STKT_UPDATE or PEER_MSG_STKT_UPDATE_TIMED stick-table
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001346 * 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 +01001347 * update ID.
1348 * <totl> is the length of the stick-table update message computed upon receipt.
1349 */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001350static int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int exp,
1351 char **msg_cur, char *msg_end, int msg_len, int totl)
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001352{
1353 struct stream_interface *si = appctx->owner;
1354 struct shared_table *st = p->remote_table;
1355 struct stksess *ts, *newts;
1356 uint32_t update;
1357 int expire;
1358 unsigned int data_type;
1359 void *data_ptr;
1360
1361 /* Here we have data message */
1362 if (!st)
1363 goto ignore_msg;
1364
1365 expire = MS_TO_TICKS(st->table->expire);
1366
1367 if (updt) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001368 if (msg_len < sizeof(update))
1369 goto malformed_exit;
1370
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001371 memcpy(&update, *msg_cur, sizeof(update));
1372 *msg_cur += sizeof(update);
1373 st->last_get = htonl(update);
1374 }
1375 else {
1376 st->last_get++;
1377 }
1378
1379 if (exp) {
1380 size_t expire_sz = sizeof expire;
1381
Willy Tarreau1e82a142019-01-29 11:08:06 +01001382 if (*msg_cur + expire_sz > msg_end)
1383 goto malformed_exit;
1384
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001385 memcpy(&expire, *msg_cur, expire_sz);
1386 *msg_cur += expire_sz;
1387 expire = ntohl(expire);
1388 }
1389
1390 newts = stksess_new(st->table, NULL);
1391 if (!newts)
1392 goto ignore_msg;
1393
1394 if (st->table->type == SMP_T_STR) {
1395 unsigned int to_read, to_store;
1396
1397 to_read = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001398 if (!*msg_cur)
1399 goto malformed_free_newts;
1400
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001401 to_store = MIN(to_read, st->table->key_size - 1);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001402 if (*msg_cur + to_store > msg_end)
1403 goto malformed_free_newts;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001404
1405 memcpy(newts->key.key, *msg_cur, to_store);
1406 newts->key.key[to_store] = 0;
1407 *msg_cur += to_read;
1408 }
1409 else if (st->table->type == SMP_T_SINT) {
1410 unsigned int netinteger;
1411
Willy Tarreau1e82a142019-01-29 11:08:06 +01001412 if (*msg_cur + sizeof(netinteger) > msg_end)
1413 goto malformed_free_newts;
1414
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001415 memcpy(&netinteger, *msg_cur, sizeof(netinteger));
1416 netinteger = ntohl(netinteger);
1417 memcpy(newts->key.key, &netinteger, sizeof(netinteger));
1418 *msg_cur += sizeof(netinteger);
1419 }
1420 else {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001421 if (*msg_cur + st->table->key_size > msg_end)
1422 goto malformed_free_newts;
1423
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001424 memcpy(newts->key.key, *msg_cur, st->table->key_size);
1425 *msg_cur += st->table->key_size;
1426 }
1427
1428 /* lookup for existing entry */
1429 ts = stktable_set_entry(st->table, newts);
1430 if (ts != newts) {
1431 stksess_free(st->table, newts);
1432 newts = NULL;
1433 }
1434
1435 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
1436
1437 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001438 uint64_t decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001439
1440 if (!((1 << data_type) & st->remote_data))
1441 continue;
1442
Willy Tarreau1e82a142019-01-29 11:08:06 +01001443 decoded_int = intdecode(msg_cur, msg_end);
1444 if (!*msg_cur)
1445 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001446
Willy Tarreau1e82a142019-01-29 11:08:06 +01001447 switch (stktable_data_types[data_type].std_type) {
1448 case STD_T_SINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001449 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1450 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001451 stktable_data_cast(data_ptr, std_t_sint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001452 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001453
Willy Tarreau1e82a142019-01-29 11:08:06 +01001454 case STD_T_UINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001455 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1456 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001457 stktable_data_cast(data_ptr, std_t_uint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001458 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001459
Willy Tarreau1e82a142019-01-29 11:08:06 +01001460 case STD_T_ULL:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001461 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1462 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001463 stktable_data_cast(data_ptr, std_t_ull) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001464 break;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001465
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001466 case STD_T_FRQP: {
1467 struct freq_ctr_period data;
1468
1469 /* First bit is reserved for the freq_ctr_period lock
1470 Note: here we're still protected by the stksess lock
1471 so we don't need to update the update the freq_ctr_period
1472 using its internal lock */
1473
Willy Tarreau1e82a142019-01-29 11:08:06 +01001474 data.curr_tick = tick_add(now_ms, -decoded_int) & ~0x1;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001475 data.curr_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001476 if (!*msg_cur)
1477 goto malformed_unlock;
1478
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001479 data.prev_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001480 if (!*msg_cur)
1481 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001482
1483 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1484 if (data_ptr)
1485 stktable_data_cast(data_ptr, std_t_frqp) = data;
1486 break;
1487 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001488 case STD_T_DICT: {
1489 struct buffer *chunk;
1490 size_t data_len, value_len;
1491 unsigned int id;
1492 struct dict_entry *de;
1493 struct dcache *dc;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001494 char *end;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001495
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +01001496 if (!decoded_int) {
1497 /* No entry. */
1498 break;
1499 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001500 data_len = decoded_int;
1501 if (*msg_cur + data_len > msg_end)
1502 goto malformed_unlock;
1503
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001504 /* Compute the end of the current data, <msg_end> being at the end of
1505 * the entire message.
1506 */
1507 end = *msg_cur + data_len;
1508 id = intdecode(msg_cur, end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001509 if (!*msg_cur || !id)
1510 goto malformed_unlock;
1511
1512 dc = p->dcache;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001513 if (*msg_cur == end) {
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001514 /* Dictionary entry key without value. */
1515 if (id > dc->max_entries)
1516 break;
1517 /* IDs sent over the network are numbered from 1. */
1518 de = dc->rx[id - 1].de;
1519 }
1520 else {
1521 chunk = get_trash_chunk();
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001522 value_len = intdecode(msg_cur, end);
1523 if (!*msg_cur || *msg_cur + value_len > end ||
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001524 unlikely(value_len + 1 >= chunk->size))
1525 goto malformed_unlock;
1526
1527 chunk_memcpy(chunk, *msg_cur, value_len);
1528 chunk->area[chunk->data] = '\0';
Frédéric Lécaille56aec0d2019-06-06 14:14:15 +02001529 *msg_cur += value_len;
1530
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001531 de = dict_insert(&server_name_dict, chunk->area);
1532 dc->rx[id - 1].de = de;
1533 }
1534 if (de) {
1535 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1536 if (data_ptr)
1537 stktable_data_cast(data_ptr, std_t_dict) = de;
1538 }
1539 break;
1540 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001541 }
1542 }
1543 /* Force new expiration */
1544 ts->expire = tick_add(now_ms, expire);
1545
1546 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1547 stktable_touch_remote(st->table, ts, 1);
1548 return 1;
1549
1550 ignore_msg:
1551 /* skip consumed message */
1552 co_skip(si_oc(si), totl);
1553 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001554
1555 malformed_unlock:
1556 /* malformed message */
1557 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1558 stktable_touch_remote(st->table, ts, 1);
1559 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1560 return 0;
1561
1562 malformed_free_newts:
1563 /* malformed message */
1564 stksess_free(st->table, newts);
1565 malformed_exit:
1566 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1567 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001568}
1569
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001570/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001571 * Function used to parse a stick-table update acknowledgement message after it
1572 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1573 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1574 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1575 * was encountered.
1576 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1577 */
1578static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1579 char **msg_cur, char *msg_end)
1580{
1581 /* ack message */
1582 uint32_t table_id ;
1583 uint32_t update;
1584 struct shared_table *st;
1585
1586 table_id = intdecode(msg_cur, msg_end);
1587 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1588 /* malformed message */
1589 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1590 return 0;
1591 }
1592
1593 memcpy(&update, *msg_cur, sizeof(update));
1594 update = ntohl(update);
1595
1596 for (st = p->tables; st; st = st->next) {
1597 if (st->local_id == table_id) {
1598 st->update = update;
1599 break;
1600 }
1601 }
1602
1603 return 1;
1604}
1605
1606/*
1607 * Function used to parse a stick-table switch message after it has been received
1608 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1609 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1610 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1611 * was encountered.
1612 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1613 */
1614static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1615 char **msg_cur, char *msg_end)
1616{
1617 struct shared_table *st;
1618 int table_id;
1619
1620 table_id = intdecode(msg_cur, msg_end);
1621 if (!*msg_cur) {
1622 /* malformed message */
1623 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1624 return 0;
1625 }
1626
1627 p->remote_table = NULL;
1628 for (st = p->tables; st; st = st->next) {
1629 if (st->remote_id == table_id) {
1630 p->remote_table = st;
1631 break;
1632 }
1633 }
1634
1635 return 1;
1636}
1637
1638/*
1639 * Function used to parse a stick-table definition message after it has been received
1640 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1641 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1642 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1643 * was encountered.
1644 * <totl> is the length of the stick-table update message computed upon receipt.
1645 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1646 */
1647static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1648 char **msg_cur, char *msg_end, int totl)
1649{
1650 struct stream_interface *si = appctx->owner;
1651 int table_id_len;
1652 struct shared_table *st;
1653 int table_type;
1654 int table_keylen;
1655 int table_id;
1656 uint64_t table_data;
1657
1658 table_id = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001659 if (!*msg_cur)
1660 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001661
1662 table_id_len = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001663 if (!*msg_cur)
1664 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001665
1666 p->remote_table = NULL;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001667 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end)
1668 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001669
1670 for (st = p->tables; st; st = st->next) {
1671 /* Reset IDs */
1672 if (st->remote_id == table_id)
1673 st->remote_id = 0;
1674
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001675 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1676 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001677 p->remote_table = st;
1678 }
1679
1680 if (!p->remote_table)
1681 goto ignore_msg;
1682
1683 *msg_cur += table_id_len;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001684 if (*msg_cur >= msg_end)
1685 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001686
1687 table_type = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001688 if (!*msg_cur)
1689 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001690
1691 table_keylen = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001692 if (!*msg_cur)
1693 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001694
1695 table_data = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001696 if (!*msg_cur)
1697 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001698
Emeric Brun530ba382020-06-02 11:17:42 +02001699 if (p->remote_table->table->type != peer_int_key_type[table_type]
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001700 || p->remote_table->table->key_size != table_keylen) {
1701 p->remote_table = NULL;
1702 goto ignore_msg;
1703 }
1704
1705 p->remote_table->remote_data = table_data;
1706 p->remote_table->remote_id = table_id;
1707 return 1;
1708
1709 ignore_msg:
1710 co_skip(si_oc(si), totl);
1711 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001712
1713 malformed_exit:
1714 /* malformed message */
1715 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1716 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001717}
1718
1719/*
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001720 * Receive a stick-table message.
1721 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1722 * -1 if there was an error updating the appctx state st0 accordingly.
1723 */
1724static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1725 uint32_t *msg_len, int *totl)
1726{
1727 int reql;
1728 struct stream_interface *si = appctx->owner;
1729
1730 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1731 if (reql <= 0) /* closed or EOL not found */
1732 goto incomplete;
1733
1734 *totl += reql;
1735
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001736 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001737 return 1;
1738
1739 /* Read and Decode message length */
1740 reql = co_getblk(si_oc(si), &msg_head[2], sizeof(char), *totl);
1741 if (reql <= 0) /* closed */
1742 goto incomplete;
1743
1744 *totl += reql;
1745
Frédéric Lécaille32b55732019-06-03 18:29:51 +02001746 if ((unsigned int)msg_head[2] < PEER_ENC_2BYTES_MIN) {
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001747 *msg_len = msg_head[2];
1748 }
1749 else {
1750 int i;
1751 char *cur;
1752 char *end;
1753
1754 for (i = 3 ; i < msg_head_sz ; i++) {
1755 reql = co_getblk(si_oc(si), &msg_head[i], sizeof(char), *totl);
1756 if (reql <= 0) /* closed */
1757 goto incomplete;
1758
1759 *totl += reql;
1760
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001761 if (!(msg_head[i] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001762 break;
1763 }
1764
1765 if (i == msg_head_sz) {
1766 /* malformed message */
1767 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1768 return -1;
1769 }
1770 end = msg_head + msg_head_sz;
1771 cur = &msg_head[2];
1772 *msg_len = intdecode(&cur, end);
1773 if (!cur) {
1774 /* malformed message */
1775 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1776 return -1;
1777 }
1778 }
1779
1780 /* Read message content */
1781 if (*msg_len) {
1782 if (*msg_len > trash.size) {
1783 /* Status code is not success, abort */
1784 appctx->st0 = PEER_SESS_ST_ERRSIZE;
1785 return -1;
1786 }
1787
1788 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
1789 if (reql <= 0) /* closed */
1790 goto incomplete;
1791 *totl += reql;
1792 }
1793
1794 return 1;
1795
1796 incomplete:
1797 if (reql < 0) {
1798 /* there was an error */
1799 appctx->st0 = PEER_SESS_ST_END;
1800 return -1;
1801 }
1802
1803 return 0;
1804}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001805
1806/*
1807 * Treat the awaited message with <msg_head> as header.*
1808 * Return 1 if succeeded, 0 if not.
1809 */
1810static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
1811 char **msg_cur, char *msg_end, int msg_len, int totl)
1812{
1813 struct stream_interface *si = appctx->owner;
1814 struct stream *s = si_strm(si);
1815 struct peers *peers = strm_fe(s)->parent;
1816
1817 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
1818 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
1819 struct shared_table *st;
1820 /* Reset message: remote need resync */
1821
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001822 /* prepare tables for a global push */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001823 for (st = peer->tables; st; st = st->next) {
1824 st->teaching_origin = st->last_pushed = st->table->update;
1825 st->flags = 0;
1826 }
1827
1828 /* reset teaching flags to 0 */
1829 peer->flags &= PEER_TEACH_RESET;
1830
1831 /* flag to start to teach lesson */
1832 peer->flags |= PEER_F_TEACH_PROCESS;
1833 }
1834 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
1835 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1836 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1837 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1838 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
1839 }
1840 peer->confirm++;
1841 }
1842 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
1843 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1844 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1845 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1846
1847 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001848 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001849 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
1850 }
1851 peer->confirm++;
1852 }
1853 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
1854 struct shared_table *st;
1855
1856 /* If stopping state */
1857 if (stopping) {
1858 /* Close session, push resync no more needed */
1859 peer->flags |= PEER_F_TEACH_COMPLETE;
1860 appctx->st0 = PEER_SESS_ST_END;
1861 return 0;
1862 }
1863 for (st = peer->tables; st; st = st->next) {
1864 st->update = st->last_pushed = st->teaching_origin;
1865 st->flags = 0;
1866 }
1867
1868 /* reset teaching flags to 0 */
1869 peer->flags &= PEER_TEACH_RESET;
1870 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001871 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001872 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01001873 peer->rx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001874 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001875 }
1876 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
1877 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
1878 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
1879 return 0;
1880 }
1881 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
1882 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
1883 return 0;
1884 }
1885 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
1886 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
1887 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
1888 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
1889 int update, expire;
1890
1891 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
1892 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
1893 if (!peer_treat_updatemsg(appctx, peer, update, expire,
1894 msg_cur, msg_end, msg_len, totl))
1895 return 0;
1896
1897 }
1898 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
1899 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
1900 return 0;
1901 }
1902 }
1903 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
1904 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1905 return 0;
1906 }
1907
1908 return 1;
1909}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001910
1911
1912/*
1913 * Send any message to <peer> peer.
1914 * Returns 1 if succeeded, or -1 or 0 if failed.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001915 * -1 means an internal error occurred, 0 is for a peer protocol error leading
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001916 * to a peer state change (from the peer I/O handler point of view).
1917 */
1918static inline int peer_send_msgs(struct appctx *appctx, struct peer *peer)
1919{
1920 int repl;
1921 struct stream_interface *si = appctx->owner;
1922 struct stream *s = si_strm(si);
1923 struct peers *peers = strm_fe(s)->parent;
1924
1925 /* Need to request a resync */
1926 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
1927 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
1928 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
1929
1930 repl = peer_send_resync_reqmsg(appctx);
1931 if (repl <= 0)
1932 return repl;
1933
1934 peers->flags |= PEERS_F_RESYNC_PROCESS;
1935 }
1936
1937 /* Nothing to read, now we start to write */
1938 if (peer->tables) {
1939 struct shared_table *st;
1940 struct shared_table *last_local_table;
1941
1942 last_local_table = peer->last_local_table;
1943 if (!last_local_table)
1944 last_local_table = peer->tables;
1945 st = last_local_table->next;
1946
1947 while (1) {
1948 if (!st)
1949 st = peer->tables;
1950
1951 /* It remains some updates to ack */
1952 if (st->last_get != st->last_acked) {
1953 repl = peer_send_ackmsg(st, appctx);
1954 if (repl <= 0)
1955 return repl;
1956
1957 st->last_acked = st->last_get;
1958 }
1959
1960 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
1961 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1962 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
1963 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
1964
1965 repl = peer_send_teach_process_msgs(appctx, peer, st);
1966 if (repl <= 0) {
1967 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1968 return repl;
1969 }
1970 }
1971 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1972 }
1973 else {
1974 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
1975 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
1976 if (repl <= 0)
1977 return repl;
1978 }
1979
1980 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
1981 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
1982 if (repl <= 0)
1983 return repl;
1984 }
1985 }
1986
1987 if (st == last_local_table)
1988 break;
1989 st = st->next;
1990 }
1991 }
1992
1993 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
Emeric Brun70de43b2020-03-16 10:51:01 +01001994 repl = peer_send_resync_finishedmsg(appctx, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001995 if (repl <= 0)
1996 return repl;
1997
1998 /* flag finished message sent */
1999 peer->flags |= PEER_F_TEACH_FINISHED;
2000 }
2001
2002 /* Confirm finished or partial messages */
2003 while (peer->confirm) {
2004 repl = peer_send_resync_confirmsg(appctx);
2005 if (repl <= 0)
2006 return repl;
2007
2008 peer->confirm--;
2009 }
2010
2011 return 1;
2012}
2013
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002014/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002015 * Read and parse a first line of a "hello" peer protocol message.
2016 * Returns 0 if could not read a line, -1 if there was a read error or
2017 * the line is malformed, 1 if succeeded.
2018 */
2019static inline int peer_getline_version(struct appctx *appctx,
2020 unsigned int *maj_ver, unsigned int *min_ver)
2021{
2022 int reql;
2023
2024 reql = peer_getline(appctx);
2025 if (!reql)
2026 return 0;
2027
2028 if (reql < 0)
2029 return -1;
2030
2031 /* test protocol */
2032 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
2033 appctx->st0 = PEER_SESS_ST_EXIT;
2034 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2035 return -1;
2036 }
2037 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
2038 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
2039 appctx->st0 = PEER_SESS_ST_EXIT;
2040 appctx->st1 = PEER_SESS_SC_ERRVERSION;
2041 return -1;
2042 }
2043
2044 return 1;
2045}
2046
2047/*
2048 * Read and parse a second line of a "hello" peer protocol message.
2049 * Returns 0 if could not read a line, -1 if there was a read error or
2050 * the line is malformed, 1 if succeeded.
2051 */
2052static inline int peer_getline_host(struct appctx *appctx)
2053{
2054 int reql;
2055
2056 reql = peer_getline(appctx);
2057 if (!reql)
2058 return 0;
2059
2060 if (reql < 0)
2061 return -1;
2062
2063 /* test hostname match */
2064 if (strcmp(localpeer, trash.area) != 0) {
2065 appctx->st0 = PEER_SESS_ST_EXIT;
2066 appctx->st1 = PEER_SESS_SC_ERRHOST;
2067 return -1;
2068 }
2069
2070 return 1;
2071}
2072
2073/*
2074 * Read and parse a last line of a "hello" peer protocol message.
2075 * Returns 0 if could not read a character, -1 if there was a read error or
2076 * the line is malformed, 1 if succeeded.
2077 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2078 */
2079static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2080{
2081 char *p;
2082 int reql;
2083 struct peer *peer;
2084 struct stream_interface *si = appctx->owner;
2085 struct stream *s = si_strm(si);
2086 struct peers *peers = strm_fe(s)->parent;
2087
2088 reql = peer_getline(appctx);
2089 if (!reql)
2090 return 0;
2091
2092 if (reql < 0)
2093 return -1;
2094
2095 /* parse line "<peer name> <pid> <relative_pid>" */
2096 p = strchr(trash.area, ' ');
2097 if (!p) {
2098 appctx->st0 = PEER_SESS_ST_EXIT;
2099 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2100 return -1;
2101 }
2102 *p = 0;
2103
2104 /* lookup known peer */
2105 for (peer = peers->remote; peer; peer = peer->next) {
2106 if (strcmp(peer->id, trash.area) == 0)
2107 break;
2108 }
2109
2110 /* if unknown peer */
2111 if (!peer) {
2112 appctx->st0 = PEER_SESS_ST_EXIT;
2113 appctx->st1 = PEER_SESS_SC_ERRPEER;
2114 return -1;
2115 }
2116 *curpeer = peer;
2117
2118 return 1;
2119}
2120
2121/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002122 * Init <peer> peer after having accepted it at peer protocol level.
2123 */
2124static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2125{
2126 struct shared_table *st;
2127
2128 /* Register status code */
2129 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
2130
2131 /* Awake main task */
2132 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2133
2134 /* Init confirm counter */
2135 peer->confirm = 0;
2136
2137 /* Init cursors */
2138 for (st = peer->tables; st ; st = st->next) {
2139 st->last_get = st->last_acked = 0;
2140 st->teaching_origin = st->last_pushed = st->update;
2141 }
2142
2143 /* reset teaching and learning flags to 0 */
2144 peer->flags &= PEER_TEACH_RESET;
2145 peer->flags &= PEER_LEARN_RESET;
2146
2147 /* if current peer is local */
2148 if (peer->local) {
2149 /* if current host need resyncfrom local and no process assined */
2150 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2151 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2152 /* assign local peer for a lesson, consider lesson already requested */
2153 peer->flags |= PEER_F_LEARN_ASSIGN;
2154 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2155 }
2156
2157 }
2158 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2159 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2160 /* assign peer for a lesson */
2161 peer->flags |= PEER_F_LEARN_ASSIGN;
2162 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2163 }
2164}
2165
2166/*
2167 * Init <peer> peer after having connected it at peer protocol level.
2168 */
2169static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2170{
2171 struct shared_table *st;
2172
2173 /* Init cursors */
2174 for (st = peer->tables; st ; st = st->next) {
2175 st->last_get = st->last_acked = 0;
2176 st->teaching_origin = st->last_pushed = st->update;
2177 }
2178
2179 /* Init confirm counter */
2180 peer->confirm = 0;
2181
2182 /* reset teaching and learning flags to 0 */
2183 peer->flags &= PEER_TEACH_RESET;
2184 peer->flags &= PEER_LEARN_RESET;
2185
2186 /* If current peer is local */
2187 if (peer->local) {
2188 /* flag to start to teach lesson */
2189 peer->flags |= PEER_F_TEACH_PROCESS;
2190 }
2191 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2192 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2193 /* If peer is remote and resync from remote is needed,
2194 and no peer currently assigned */
2195
2196 /* assign peer for a lesson */
2197 peer->flags |= PEER_F_LEARN_ASSIGN;
2198 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2199 }
2200}
2201
2202/*
Emeric Brun2b920a12010-09-23 18:30:22 +02002203 * IO Handler to handle message exchance with a peer
2204 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002205static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002206{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002207 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002208 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002209 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002210 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002211 int reql = 0;
2212 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002213 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002214 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002215
Joseph Herlant82b2f542018-11-15 12:19:14 -08002216 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002217 if (si_ic(si)->buf.size == 0) {
2218 si_rx_room_blk(si);
2219 goto out;
2220 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002221
Emeric Brun2b920a12010-09-23 18:30:22 +02002222 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002223 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002224switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002225 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002226 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002227 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002228 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002229 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002230 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002231 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002232 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002233 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002234 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2235 if (reql <= 0) {
2236 if (!reql)
2237 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002238 goto switchstate;
2239 }
2240
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002241 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002242 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002243 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002244 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002245 reql = peer_getline_host(appctx);
2246 if (reql <= 0) {
2247 if (!reql)
2248 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002249 goto switchstate;
2250 }
2251
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002252 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002253 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002254 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002255 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002256 reql = peer_getline_last(appctx, &curpeer);
2257 if (reql <= 0) {
2258 if (!reql)
2259 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002260 goto switchstate;
2261 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002262
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002263 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002264 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002265 if (curpeer->local) {
2266 /* Local connection, reply a retry */
2267 appctx->st0 = PEER_SESS_ST_EXIT;
2268 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2269 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002270 }
Emeric Brun80527f52017-06-19 17:46:37 +02002271
2272 /* we're killing a connection, we must apply a random delay before
2273 * retrying otherwise the other end will do the same and we can loop
2274 * for a while.
2275 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002276 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002277 peer_session_forceshutdown(curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002278 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002279 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2280 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2281 curpeer->flags |= PEER_F_DWNGRD;
2282 }
2283 else {
2284 curpeer->flags &= ~PEER_F_DWNGRD;
2285 }
2286 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002287 curpeer->appctx = appctx;
2288 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002289 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002290 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002291 /* fall through */
2292 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002293 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002294 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002295 if (!curpeer) {
2296 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002297 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002298 if (curpeer->appctx != appctx) {
2299 appctx->st0 = PEER_SESS_ST_END;
2300 goto switchstate;
2301 }
2302 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002303
2304 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002305 if (repl <= 0) {
2306 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002307 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002308 goto switchstate;
2309 }
2310
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002311 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002312
Emeric Brun2b920a12010-09-23 18:30:22 +02002313 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002314 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002315 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002316 goto switchstate;
2317 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002318 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002319 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002320 if (!curpeer) {
2321 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002322 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002323 if (curpeer->appctx != appctx) {
2324 appctx->st0 = PEER_SESS_ST_END;
2325 goto switchstate;
2326 }
2327 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002328
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002329 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002330 if (repl <= 0) {
2331 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002332 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002333 goto switchstate;
2334 }
2335
2336 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002337 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002338 /* fall through */
2339 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002340 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002341 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002342 if (!curpeer) {
2343 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002344 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002345 if (curpeer->appctx != appctx) {
2346 appctx->st0 = PEER_SESS_ST_END;
2347 goto switchstate;
2348 }
2349 }
2350
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002351 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002352 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002353
Frédéric Lécaillece025572019-01-21 13:38:06 +01002354 reql = peer_getline(appctx);
2355 if (!reql)
2356 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002357
Frédéric Lécaillece025572019-01-21 13:38:06 +01002358 if (reql < 0)
2359 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002360
2361 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002362 curpeer->statuscode = atoi(trash.area);
Emeric Brun2b920a12010-09-23 18:30:22 +02002363
2364 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002365 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002366
2367 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002368 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002369 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002370 }
2371 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002372 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2373 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002374 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002375 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002376 goto switchstate;
2377 }
Olivier Houcharded879892019-03-08 18:53:43 +01002378 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002379 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002380 /* fall through */
2381 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002382 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002383 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002384 char *msg_cur = trash.area;
2385 char *msg_end = trash.area;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002386 unsigned char msg_head[7];
Emeric Brun2b920a12010-09-23 18:30:22 +02002387 int totl = 0;
2388
Willy Tarreau2d372c22018-11-05 17:12:27 +01002389 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002390 if (!curpeer) {
2391 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002392 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002393 if (curpeer->appctx != appctx) {
2394 appctx->st0 = PEER_SESS_ST_END;
2395 goto switchstate;
2396 }
2397 }
2398
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002399 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2400 if (reql <= 0) {
2401 if (reql == -1)
2402 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002403 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002404 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002405
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002406 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002407 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002408 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002409
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002410 curpeer->flags |= PEER_F_ALIVE;
2411
Emeric Brun2b920a12010-09-23 18:30:22 +02002412 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002413 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002414 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002415 goto switchstate;
2416
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002417send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002418 if (curpeer->flags & PEER_F_HEARTBEAT) {
2419 curpeer->flags &= ~PEER_F_HEARTBEAT;
2420 repl = peer_send_heartbeatmsg(appctx);
2421 if (repl <= 0) {
2422 if (repl == -1)
2423 goto out;
2424 goto switchstate;
2425 }
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002426 curpeer->tx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002427 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002428 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002429 repl = peer_send_msgs(appctx, curpeer);
2430 if (repl <= 0) {
2431 if (repl == -1)
2432 goto out;
2433 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002434 }
2435
Emeric Brun2b920a12010-09-23 18:30:22 +02002436 /* noting more to do */
2437 goto out;
2438 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002439 case PEER_SESS_ST_EXIT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002440 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002441 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002442 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002443 if (peer_send_status_errormsg(appctx) == -1)
2444 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002445 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002446 goto switchstate;
2447 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002448 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002449 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002450 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002451 if (peer_send_error_size_limitmsg(appctx) == -1)
2452 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002453 appctx->st0 = PEER_SESS_ST_END;
2454 goto switchstate;
2455 }
2456 case PEER_SESS_ST_ERRPROTO: {
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002457 if (curpeer)
2458 curpeer->proto_err++;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002459 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002460 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002461 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002462 if (peer_send_error_protomsg(appctx) == -1)
2463 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002464 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002465 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002466 /* fall through */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002467 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002468 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002469 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002470 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002471 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002472 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002473 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002474 curpeer = NULL;
2475 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002476 si_shutw(si);
2477 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002478 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002479 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002480 }
2481 }
2482 }
2483out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002484 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002485
2486 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002487 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002488 return;
2489}
2490
Willy Tarreau30576452015-04-13 13:50:30 +02002491static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002492 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002493 .name = "<PEER>", /* used for logging */
2494 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002495 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002496};
Emeric Brun2b920a12010-09-23 18:30:22 +02002497
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002498
Emeric Brun2b920a12010-09-23 18:30:22 +02002499/*
2500 * Use this function to force a close of a peer session
2501 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002502static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002503{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002504 struct appctx *appctx = peer->appctx;
2505
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002506 /* Note that the peer sessions which have just been created
2507 * (->st0 == PEER_SESS_ST_CONNECT) must not
2508 * be shutdown, if not, the TCP session will never be closed
2509 * and stay in CLOSE_WAIT state after having been closed by
2510 * the remote side.
2511 */
2512 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002513 return;
2514
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002515 if (appctx->applet != &peer_applet)
2516 return;
2517
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002518 __peer_session_deinit(peer);
2519
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002520 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002521 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002522}
2523
Willy Tarreau91d96282015-03-13 15:47:26 +01002524/* Pre-configures a peers frontend to accept incoming connections */
2525void peers_setup_frontend(struct proxy *fe)
2526{
2527 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002528 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreau91d96282015-03-13 15:47:26 +01002529 fe->maxconn = 0;
2530 fe->conn_retries = CONN_RETRIES;
2531 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002532 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002533 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002534 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002535 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002536}
2537
Emeric Brun2b920a12010-09-23 18:30:22 +02002538/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002539 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002540 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002541static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002542{
Willy Tarreau04b92862017-09-15 11:01:04 +02002543 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002544 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002545 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002546 struct stream *s;
Emeric Brun2b920a12010-09-23 18:30:22 +02002547
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002548 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002549 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Emeric Brunb3971ab2015-05-12 18:49:09 +02002550 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002551 s = NULL;
2552
Emeric Brun1138fd02017-06-19 12:38:55 +02002553 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002554 if (!appctx)
2555 goto out_close;
2556
2557 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002558 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002559
Willy Tarreau04b92862017-09-15 11:01:04 +02002560 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002561 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002562 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002563 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002564 }
2565
Willy Tarreau87787ac2017-08-28 16:22:54 +02002566 if ((s = stream_new(sess, &appctx->obj_type)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002567 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002568 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002569 }
2570
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002571 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002572 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002573 appctx_wakeup(appctx);
2574
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002575 /* initiate an outgoing connection */
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002576 s->target = peer_session_target(peer, s);
2577 if (!sockaddr_alloc(&s->target_addr))
2578 goto out_free_strm;
2579 *s->target_addr = peer->addr;
Willy Tarreau02efeda2019-07-18 17:21:24 +02002580 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Willy Tarreaudbd02672017-12-06 17:39:53 +01002581 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002582
Emeric Brun2b920a12010-09-23 18:30:22 +02002583 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002584 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002585
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002586 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002587
Emeric Brunb3971ab2015-05-12 18:49:09 +02002588 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002589 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002590 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002591 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002592
2593 /* Error unrolling */
Willy Tarreau15b5e142015-04-04 14:38:25 +02002594 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002595 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002596 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002597 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002598 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002599 out_free_appctx:
2600 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002601 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002602 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002603}
2604
2605/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002606 * Task processing function to manage re-connect, peer session
2607 * tasks wakeup on local update and heartbeat.
Emeric Brun2b920a12010-09-23 18:30:22 +02002608 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02002609static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002610{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002611 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002612 struct peer *ps;
2613 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002614
2615 task->expire = TICK_ETERNITY;
2616
Emeric Brunb3971ab2015-05-12 18:49:09 +02002617 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002618 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002619 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002620 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002621 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002622 return NULL;
2623 }
2624
Emeric Brun80527f52017-06-19 17:46:37 +02002625 /* Acquire lock for all peers of the section */
2626 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002627 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002628
Emeric Brun2b920a12010-09-23 18:30:22 +02002629 if (!stopping) {
2630 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002631
2632 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2633 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2634 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002635 /* Resync from local peer needed
2636 no peer was assigned for the lesson
2637 and no old local peer found
2638 or resync timeout expire */
2639
2640 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002641 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002642
2643 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002644 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002645 }
2646
2647 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002648 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002649 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002650 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002651 if (!ps->appctx) {
2652 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002653 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002654 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002655 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002656 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002657 tick_is_expired(ps->reconnect, now_ms))) {
2658 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002659 * or previous peer connection established with success
2660 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002661 * and reconnection timer is expired */
2662
2663 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002664 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002665 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002666 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002667 /* If previous session failed during connection
2668 * but reconnection timer is not expired */
2669
2670 /* reschedule task for reconnect */
2671 task->expire = tick_first(task->expire, ps->reconnect);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002672 ps->new_conn++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002673 }
2674 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002675 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002676 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002677 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002678 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2679 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002680 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2681 /* Resync from a remote is needed
2682 * and no peer was assigned for lesson
2683 * and current peer may be up2date */
2684
2685 /* assign peer for the lesson */
2686 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002687 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002688
Willy Tarreau9df94c22016-10-31 18:42:52 +01002689 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002690 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002691 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002692 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002693 int update_to_push = 0;
2694
Emeric Brunb3971ab2015-05-12 18:49:09 +02002695 /* Awake session if there is data to push */
2696 for (st = ps->tables; st ; st = st->next) {
2697 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002698 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002699 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002700 /* There is no need to send a heartbeat message
2701 * when some updates must be pushed. The remote
2702 * peer will consider <ps> peer as alive when it will
2703 * receive these updates.
2704 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002705 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002706 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002707 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002708 /* We are going to send updates, let's ensure we will
2709 * come back to send heartbeat messages or to reconnect.
2710 */
2711 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002712 appctx_wakeup(ps->appctx);
2713 break;
2714 }
2715 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002716 /* When there are updates to send we do not reconnect
2717 * and do not send heartbeat message either.
2718 */
2719 if (!update_to_push) {
2720 if (tick_is_expired(ps->reconnect, now_ms)) {
2721 if (ps->flags & PEER_F_ALIVE) {
2722 /* This peer was alive during a 'reconnect' period.
2723 * Flag it as not alive again for the next period.
2724 */
2725 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002726 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002727 }
2728 else {
Willy Tarreau52bf8392020-03-08 00:42:37 +01002729 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002730 peer_session_forceshutdown(ps);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002731 ps->no_hbt++;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002732 }
2733 }
2734 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2735 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
2736 ps->flags |= PEER_F_HEARTBEAT;
2737 appctx_wakeup(ps->appctx);
2738 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01002739 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002740 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002741 }
2742 /* else do nothing */
2743 } /* SUCCESSCODE */
2744 } /* !ps->peer->local */
2745 } /* for */
2746
2747 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002748 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2749 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2750 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002751 /* Resync from remote peer needed
2752 * no peer was assigned for the lesson
2753 * and resync timeout expire */
2754
2755 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002756 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002757 }
2758
Emeric Brunb3971ab2015-05-12 18:49:09 +02002759 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002760 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02002761 /* reschedule task to resync timeout if not expired, to ended resync if needed */
2762 if (!tick_is_expired(peers->resync_timeout, now_ms))
2763 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02002764 }
2765 } /* !stopping */
2766 else {
2767 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01002768 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08002769 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002770 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002771 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01002772 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002773 peers->flags |= PEERS_F_DONOTSTOP;
2774 ps = peers->local;
2775 for (st = ps->tables; st ; st = st->next)
2776 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002777 }
2778
2779 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002780 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02002781 /* we're killing a connection, we must apply a random delay before
2782 * retrying otherwise the other end will do the same and we can loop
2783 * for a while.
2784 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002785 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01002786 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002787 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002788 }
2789 }
2790 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002791
Emeric Brunb3971ab2015-05-12 18:49:09 +02002792 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02002793 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002794 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002795 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002796 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002797 peers->flags &= ~PEERS_F_DONOTSTOP;
2798 for (st = ps->tables; st ; st = st->next)
2799 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002800 }
2801 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01002802 else if (!ps->appctx) {
2803 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002804 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002805 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
2806 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
2807 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002808 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002809 * or previous peer connection was successfully established
2810 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02002811 * or during previous connect, peer replies a try again statuscode */
2812
2813 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002814 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002815 }
2816 else {
2817 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002818 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002819 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002820 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002821 peers->flags &= ~PEERS_F_DONOTSTOP;
2822 for (st = ps->tables; st ; st = st->next)
2823 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002824 }
2825 }
2826 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002827 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002828 /* current peer connection is active and established
2829 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002830 for (st = ps->tables; st ; st = st->next) {
2831 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002832 appctx_wakeup(ps->appctx);
2833 break;
2834 }
2835 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002836 }
2837 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02002838
2839 /* Release lock for all peers of the section */
2840 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002841 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002842
Emeric Brun2b920a12010-09-23 18:30:22 +02002843 /* Wakeup for re-connect */
2844 return task;
2845}
2846
Emeric Brunb3971ab2015-05-12 18:49:09 +02002847
Emeric Brun2b920a12010-09-23 18:30:22 +02002848/*
Willy Tarreaud9443442018-10-15 11:18:03 +02002849 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02002850 */
Willy Tarreaud9443442018-10-15 11:18:03 +02002851int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02002852{
Emeric Brun2b920a12010-09-23 18:30:22 +02002853 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02002854
Emeric Brun2b920a12010-09-23 18:30:22 +02002855 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002856 peers->peers_fe->maxconn += 3;
2857 }
2858
Emeric Brunc60def82017-09-27 14:59:38 +02002859 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02002860 if (!peers->sync_task)
2861 return 0;
2862
Emeric Brunb3971ab2015-05-12 18:49:09 +02002863 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002864 peers->sync_task->context = (void *)peers;
2865 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
2866 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02002867 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002868}
2869
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002870/*
2871 * Allocate a cache a dictionary entries used upon transmission.
2872 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002873static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002874{
2875 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002876 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002877
2878 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002879 entries = calloc(max_entries, sizeof *entries);
2880 if (!d || !entries)
2881 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002882
2883 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002884 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002885 d->cached_entries = EB_ROOT_UNIQUE;
2886 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002887
2888 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002889
2890 err:
2891 free(d);
2892 free(entries);
2893 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002894}
2895
2896/*
2897 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
2898 * as maximum of entries.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002899 * Return the dictionary cache if succeeded, NULL if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002900 * Must be deallocated calling free_dcache().
2901 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002902static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002903{
2904 struct dcache_tx *dc_tx;
2905 struct dcache *dc;
2906 struct dcache_rx *dc_rx;
2907
2908 dc = calloc(1, sizeof *dc);
2909 dc_tx = new_dcache_tx(max_entries);
2910 dc_rx = calloc(max_entries, sizeof *dc_rx);
2911 if (!dc || !dc_tx || !dc_rx)
2912 goto err;
2913
2914 dc->tx = dc_tx;
2915 dc->rx = dc_rx;
2916 dc->max_entries = max_entries;
2917
2918 return dc;
2919
2920 err:
2921 free(dc);
2922 free(dc_tx);
2923 free(dc_rx);
2924 return NULL;
2925}
2926
2927/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002928 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
2929 * entries used upon transmission.
2930 * Return the entry if found, NULL if not.
2931 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002932static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
2933 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002934{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002935 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002936}
2937
2938/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002939 * Flush <dc> cache.
2940 * Always succeeds.
2941 */
2942static inline void flush_dcache(struct peer *peer)
2943{
2944 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002945 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002946
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002947 for (i = 0; i < dc->max_entries; i++)
2948 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002949
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002950 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002951}
2952
2953/*
2954 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
2955 * with information provided by <i> dictionary cache entry (especially the value
2956 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002957 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002958 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002959static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002960{
2961 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002962 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002963
2964 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002965
2966 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
2967 o = dc_tx->prev_lookup;
2968 } else {
2969 o = dcache_tx_lookup_value(dc_tx, i);
2970 if (o) {
2971 /* Save it */
2972 dc_tx->prev_lookup = o;
2973 }
2974 }
2975
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002976 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002977 /* Copy the ID. */
2978 i->id = o - dc->tx->entries;
2979 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002980 }
2981
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002982 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002983 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002984
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002985 ebpt_delete(o);
2986 o->key = i->entry.key;
2987 ebpt_insert(&dc_tx->cached_entries, o);
2988 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002989
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002990 /* Update the index for the next entry to put in cache */
2991 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002992
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002993 return o;
2994}
Emeric Brunb3971ab2015-05-12 18:49:09 +02002995
2996/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002997 * Allocate a dictionary cache for each peer of <peers> section.
2998 * Return 1 if succeeded, 0 if not.
2999 */
3000int peers_alloc_dcache(struct peers *peers)
3001{
3002 struct peer *p;
3003
3004 for (p = peers->remote; p; p = p->next) {
3005 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
3006 if (!p->dcache)
3007 return 0;
3008 }
3009
3010 return 1;
3011}
3012
3013/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02003014 * Function used to register a table for sync on a group of peers
3015 *
3016 */
3017void peers_register_table(struct peers *peers, struct stktable *table)
3018{
3019 struct shared_table *st;
3020 struct peer * curpeer;
3021 int id = 0;
3022
3023 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003024 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003025 st->table = table;
3026 st->next = curpeer->tables;
3027 if (curpeer->tables)
3028 id = curpeer->tables->local_id;
3029 st->local_id = id + 1;
3030
3031 curpeer->tables = st;
3032 }
3033
3034 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003035}
3036
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003037/*
3038 * Parse the "show peers" command arguments.
3039 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3040 * error message.
3041 */
3042static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3043{
3044 appctx->ctx.cfgpeers.target = NULL;
3045
3046 if (*args[2]) {
3047 struct peers *p;
3048
3049 for (p = cfg_peers; p; p = p->next) {
3050 if (!strcmp(p->id, args[2])) {
3051 appctx->ctx.cfgpeers.target = p;
3052 break;
3053 }
3054 }
3055
Willy Tarreau9d008692019-08-09 11:21:01 +02003056 if (!p)
3057 return cli_err(appctx, "No such peers\n");
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003058 }
3059
3060 return 0;
3061}
3062
3063/*
3064 * This function dumps the peer state information of <peers> "peers" section.
3065 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3066 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3067 */
3068static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3069{
3070 struct tm tm;
3071
3072 get_localtime(peers->last_change, &tm);
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003073 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 +02003074 peers,
3075 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3076 tm.tm_hour, tm.tm_min, tm.tm_sec,
3077 peers->id, peers->state, peers->flags,
3078 peers->resync_timeout ?
3079 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3080 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003081 TICKS_TO_MS(1000)) : "<NEVER>",
3082 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003083
3084 if (ci_putchk(si_ic(si), msg) == -1) {
3085 si_rx_room_blk(si);
3086 return 0;
3087 }
3088
3089 return 1;
3090}
3091
3092/*
3093 * This function dumps <peer> state information.
3094 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3095 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3096 */
3097static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3098{
3099 struct connection *conn;
3100 char pn[INET6_ADDRSTRLEN];
3101 struct stream_interface *peer_si;
3102 struct stream *peer_s;
3103 struct appctx *appctx;
3104 struct shared_table *st;
3105
3106 addr_to_str(&peer->addr, pn, sizeof pn);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003107 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 +02003108 peer, peer->id,
3109 peer->local ? "local" : "remote",
3110 pn, get_host_port(&peer->addr),
3111 statuscode_str(peer->statuscode),
3112 peer->reconnect ?
3113 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3114 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
3115 TICKS_TO_MS(1000)) : "<NEVER>",
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003116 peer->confirm, peer->tx_hbt, peer->rx_hbt,
3117 peer->no_hbt, peer->new_conn, peer->proto_err);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003118
3119 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3120
3121 appctx = peer->appctx;
3122 if (!appctx)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003123 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003124
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003125 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3126 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003127
3128 peer_si = peer->appctx->owner;
3129 if (!peer_si)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003130 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003131
3132 peer_s = si_strm(peer_si);
3133 if (!peer_s)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003134 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003135
3136 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3137
3138 conn = objt_conn(strm_orig(peer_s));
3139 if (conn)
3140 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3141
Willy Tarreau3ca14902019-07-17 14:53:15 +02003142 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 +02003143 case AF_INET:
3144 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003145 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(conn->src));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003146 break;
3147 case AF_UNIX:
3148 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3149 break;
3150 }
3151
Willy Tarreau3ca14902019-07-17 14:53:15 +02003152 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 +02003153 case AF_INET:
3154 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003155 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(conn->dst));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003156 break;
3157 case AF_UNIX:
3158 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3159 break;
3160 }
3161
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003162 table_info:
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003163 if (peer->remote_table)
3164 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3165 peer->remote_table,
3166 peer->remote_table->table->id,
3167 peer->remote_table->local_id,
3168 peer->remote_table->remote_id);
3169
3170 if (peer->last_local_table)
3171 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3172 peer->last_local_table,
3173 peer->last_local_table->table->id,
3174 peer->last_local_table->local_id,
3175 peer->last_local_table->remote_id);
3176
3177 if (peer->tables) {
3178 chunk_appendf(&trash, "\n shared tables:");
3179 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003180 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003181 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003182 struct dcache *dcache;
3183
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003184 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003185 dcache = peer->dcache;
3186
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003187 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3188 "flags=0x%x remote_data=0x%llx",
3189 st, st->local_id, st->remote_id,
3190 st->flags, (unsigned long long)st->remote_data);
3191 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3192 " teaching_origin=%u update=%u",
3193 st->last_acked, st->last_pushed, st->last_get,
3194 st->teaching_origin, st->update);
3195 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3196 " commitupdate=%u syncing=%u",
3197 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003198 chunk_appendf(&trash, "\n TX dictionary cache:");
3199 count = 0;
3200 for (i = 0; i < dcache->max_entries; i++) {
3201 struct ebpt_node *node;
3202 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003203
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003204 node = &dcache->tx->entries[i];
3205 if (!node->key)
3206 break;
3207
3208 if (!count++)
3209 chunk_appendf(&trash, "\n ");
3210 de = node->key;
3211 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3212 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003213 }
3214 chunk_appendf(&trash, "\n RX dictionary cache:");
3215 count = 0;
3216 for (i = 0; i < dcache->max_entries; i++) {
3217 if (!count++)
3218 chunk_appendf(&trash, "\n ");
3219 chunk_appendf(&trash, " %3u -> %s", i,
3220 dcache->rx[i].de ?
3221 (char *)dcache->rx[i].de->value.key : "-");
3222 count &= 0x3;
3223 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003224 }
3225 }
3226
3227 end:
3228 chunk_appendf(&trash, "\n");
3229 if (ci_putchk(si_ic(si), msg) == -1) {
3230 si_rx_room_blk(si);
3231 return 0;
3232 }
3233
3234 return 1;
3235}
3236
3237/*
3238 * This function dumps all the peers of "peers" section.
3239 * Returns 0 if the output buffer is full and needs to be called
3240 * again, non-zero if not. It proceeds in an isolated thread, so
3241 * there is no thread safety issue here.
3242 */
3243static int cli_io_handler_show_peers(struct appctx *appctx)
3244{
3245 int show_all;
3246 int ret = 0, first_peers = 1;
3247 struct stream_interface *si = appctx->owner;
3248
3249 thread_isolate();
3250
3251 show_all = !appctx->ctx.cfgpeers.target;
3252
3253 chunk_reset(&trash);
3254
3255 while (appctx->st2 != STAT_ST_FIN) {
3256 switch (appctx->st2) {
3257 case STAT_ST_INIT:
3258 if (show_all)
3259 appctx->ctx.cfgpeers.peers = cfg_peers;
3260 else
3261 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3262
3263 appctx->st2 = STAT_ST_LIST;
3264 /* fall through */
3265
3266 case STAT_ST_LIST:
3267 if (!appctx->ctx.cfgpeers.peers) {
3268 /* No more peers list. */
3269 appctx->st2 = STAT_ST_END;
3270 }
3271 else {
3272 if (!first_peers)
3273 chunk_appendf(&trash, "\n");
3274 else
3275 first_peers = 0;
3276 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3277 goto out;
3278
3279 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3280 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3281 appctx->st2 = STAT_ST_INFO;
3282 }
3283 break;
3284
3285 case STAT_ST_INFO:
3286 if (!appctx->ctx.cfgpeers.peer) {
3287 /* End of peer list */
3288 if (show_all)
3289 appctx->st2 = STAT_ST_LIST;
3290 else
3291 appctx->st2 = STAT_ST_END;
3292 }
3293 else {
3294 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3295 goto out;
3296
3297 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3298 }
3299 break;
3300
3301 case STAT_ST_END:
3302 appctx->st2 = STAT_ST_FIN;
3303 break;
3304 }
3305 }
3306 ret = 1;
3307 out:
3308 thread_release();
3309 return ret;
3310}
3311
3312/*
3313 * CLI keywords.
3314 */
3315static struct cli_kw_list cli_kws = {{ }, {
3316 { { "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, },
3317 {},
3318}};
3319
3320/* Register cli keywords */
3321INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3322