blob: 3466fa576217e0befbf73f6ecc429b9126cfa30b [file] [log] [blame]
Emeric Brun2b920a12010-09-23 18:30:22 +02001/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02002 * Peer synchro management.
Emeric Brun2b920a12010-09-23 18:30:22 +02003 *
4 * Copyright 2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <errno.h>
14#include <fcntl.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18
19#include <sys/socket.h>
20#include <sys/stat.h>
21#include <sys/types.h>
22
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020023#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020024#include <haproxy/applet.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020025#include <haproxy/channel.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020026#include <haproxy/cli.h>
Willy Tarreau3afc4c42020-06-03 18:23:19 +020027#include <haproxy/dict.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020028#include <haproxy/errors.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020029#include <haproxy/fd.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020030#include <haproxy/frontend.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020031#include <haproxy/net_helper.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020032#include <haproxy/obj_type-t.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020033#include <haproxy/peers.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020034#include <haproxy/proxy.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020035#include <haproxy/session-t.h>
Willy Tarreau3727a8a2020-06-04 17:37:26 +020036#include <haproxy/signal.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020037#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020038#include <haproxy/stick_table.h>
39#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020040#include <haproxy/stream_interface.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020041#include <haproxy/task.h>
42#include <haproxy/thread.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020043#include <haproxy/time.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020044#include <haproxy/tools.h>
Frédéric Lécailled8659352020-11-10 16:18:03 +010045#include <haproxy/trace.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020046
Emeric Brun2b920a12010-09-23 18:30:22 +020047
48/*******************************/
49/* Current peer learning state */
50/*******************************/
51
52/******************************/
Emeric Brunb3971ab2015-05-12 18:49:09 +020053/* Current peers section resync state */
Emeric Brun2b920a12010-09-23 18:30:22 +020054/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010055#define PEERS_F_RESYNC_LOCAL 0x00000001 /* Learn from local finished or no more needed */
56#define PEERS_F_RESYNC_REMOTE 0x00000002 /* Learn from remote finished or no more needed */
57#define PEERS_F_RESYNC_ASSIGN 0x00000004 /* A peer was assigned to learn our lesson */
58#define PEERS_F_RESYNC_PROCESS 0x00000008 /* The assigned peer was requested for resync */
59#define PEERS_F_DONOTSTOP 0x00010000 /* Main table sync task block process during soft stop
60 to push data to new process */
Emeric Brun2b920a12010-09-23 18:30:22 +020061
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010062#define PEERS_RESYNC_STATEMASK (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
63#define PEERS_RESYNC_FROMLOCAL 0x00000000
64#define PEERS_RESYNC_FROMREMOTE PEERS_F_RESYNC_LOCAL
65#define PEERS_RESYNC_FINISHED (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
Emeric Brunb3971ab2015-05-12 18:49:09 +020066
67/***********************************/
68/* Current shared table sync state */
69/***********************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010070#define SHTABLE_F_TEACH_STAGE1 0x00000001 /* Teach state 1 complete */
71#define SHTABLE_F_TEACH_STAGE2 0x00000002 /* Teach state 2 complete */
Emeric Brun2b920a12010-09-23 18:30:22 +020072
73/******************************/
74/* Remote peer teaching state */
75/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010076#define PEER_F_TEACH_PROCESS 0x00000001 /* Teach a lesson to current peer */
77#define PEER_F_TEACH_FINISHED 0x00000008 /* Teach conclude, (wait for confirm) */
78#define PEER_F_TEACH_COMPLETE 0x00000010 /* All that we know already taught to current peer, used only for a local peer */
79#define PEER_F_LEARN_ASSIGN 0x00000100 /* Current peer was assigned for a lesson */
80#define PEER_F_LEARN_NOTUP2DATE 0x00000200 /* Learn from peer finished but peer is not up to date */
81#define PEER_F_ALIVE 0x20000000 /* Used to flag a peer a alive. */
82#define PEER_F_HEARTBEAT 0x40000000 /* Heartbeat message to send. */
83#define PEER_F_DWNGRD 0x80000000 /* When this flag is enabled, we must downgrade the supported version announced during peer sessions. */
Emeric Brun2b920a12010-09-23 18:30:22 +020084
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010085#define PEER_TEACH_RESET ~(PEER_F_TEACH_PROCESS|PEER_F_TEACH_FINISHED) /* PEER_F_TEACH_COMPLETE should never be reset */
86#define PEER_LEARN_RESET ~(PEER_F_LEARN_ASSIGN|PEER_F_LEARN_NOTUP2DATE)
Emeric Brun2b920a12010-09-23 18:30:22 +020087
Frédéric Lécaille54bff832019-03-26 10:25:20 +010088#define PEER_RESYNC_TIMEOUT 5000 /* 5 seconds */
89#define PEER_RECONNECT_TIMEOUT 5000 /* 5 seconds */
Frédéric Lécaille645635d2019-02-11 17:49:39 +010090#define PEER_HEARTBEAT_TIMEOUT 3000 /* 3 seconds */
91
Emeric Brunb3971ab2015-05-12 18:49:09 +020092/*****************************/
93/* Sync message class */
94/*****************************/
95enum {
96 PEER_MSG_CLASS_CONTROL = 0,
97 PEER_MSG_CLASS_ERROR,
98 PEER_MSG_CLASS_STICKTABLE = 10,
99 PEER_MSG_CLASS_RESERVED = 255,
100};
101
102/*****************************/
103/* control message types */
104/*****************************/
105enum {
106 PEER_MSG_CTRL_RESYNCREQ = 0,
107 PEER_MSG_CTRL_RESYNCFINISHED,
108 PEER_MSG_CTRL_RESYNCPARTIAL,
109 PEER_MSG_CTRL_RESYNCCONFIRM,
Frédéric Lécaille645635d2019-02-11 17:49:39 +0100110 PEER_MSG_CTRL_HEARTBEAT,
Emeric Brunb3971ab2015-05-12 18:49:09 +0200111};
112
113/*****************************/
114/* error message types */
115/*****************************/
116enum {
117 PEER_MSG_ERR_PROTOCOL = 0,
118 PEER_MSG_ERR_SIZELIMIT,
119};
120
Emeric Brun530ba382020-06-02 11:17:42 +0200121/* network key types;
122 * network types were directly and mistakenly
123 * mapped on sample types, to keep backward
124 * compatiblitiy we keep those values but
125 * we now use a internal/network mapping
126 * to avoid further mistakes adding or
127 * modifying internals types
128 */
129enum {
130 PEER_KT_ANY = 0, /* any type */
131 PEER_KT_RESV1, /* UNUSED */
132 PEER_KT_SINT, /* signed 64bits integer type */
133 PEER_KT_RESV3, /* UNUSED */
134 PEER_KT_IPV4, /* ipv4 type */
135 PEER_KT_IPV6, /* ipv6 type */
136 PEER_KT_STR, /* char string type */
137 PEER_KT_BIN, /* buffer type */
138 PEER_KT_TYPES /* number of types, must always be last */
139};
140
141/* Map used to retrieve network type from internal type
142 * Note: Undeclared mapping maps entry to PEER_KT_ANY == 0
143 */
144static int peer_net_key_type[SMP_TYPES] = {
145 [SMP_T_SINT] = PEER_KT_SINT,
146 [SMP_T_IPV4] = PEER_KT_IPV4,
147 [SMP_T_IPV6] = PEER_KT_IPV6,
148 [SMP_T_STR] = PEER_KT_STR,
149 [SMP_T_BIN] = PEER_KT_BIN,
150};
151
152/* Map used to retrieve internal type from external type
153 * Note: Undeclared mapping maps entry to SMP_T_ANY == 0
154 */
155static int peer_int_key_type[PEER_KT_TYPES] = {
156 [PEER_KT_SINT] = SMP_T_SINT,
157 [PEER_KT_IPV4] = SMP_T_IPV4,
158 [PEER_KT_IPV6] = SMP_T_IPV6,
159 [PEER_KT_STR] = SMP_T_STR,
160 [PEER_KT_BIN] = SMP_T_BIN,
161};
162
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100163/*
164 * Parameters used by functions to build peer protocol messages. */
165struct peer_prep_params {
166 struct {
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100167 struct peer *peer;
168 } hello;
169 struct {
170 unsigned int st1;
171 } error_status;
172 struct {
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100173 struct stksess *stksess;
174 struct shared_table *shared_table;
175 unsigned int updateid;
176 int use_identifier;
177 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200178 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100179 } updt;
180 struct {
181 struct shared_table *shared_table;
182 } swtch;
183 struct {
184 struct shared_table *shared_table;
185 } ack;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100186 struct {
187 unsigned char head[2];
188 } control;
189 struct {
190 unsigned char head[2];
191 } error;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100192};
Emeric Brunb3971ab2015-05-12 18:49:09 +0200193
194/*******************************/
195/* stick table sync mesg types */
196/* Note: ids >= 128 contains */
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500197/* id message contains data */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200198/*******************************/
Olivier Houchard33992262018-10-16 18:49:26 +0200199#define PEER_MSG_STKT_UPDATE 0x80
200#define PEER_MSG_STKT_INCUPDATE 0x81
201#define PEER_MSG_STKT_DEFINE 0x82
202#define PEER_MSG_STKT_SWITCH 0x83
203#define PEER_MSG_STKT_ACK 0x84
204#define PEER_MSG_STKT_UPDATE_TIMED 0x85
205#define PEER_MSG_STKT_INCUPDATE_TIMED 0x86
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +0200206/* All the stick-table message identifiers abova have the #7 bit set */
207#define PEER_MSG_STKT_BIT 7
208#define PEER_MSG_STKT_BIT_MASK (1 << PEER_MSG_STKT_BIT)
Emeric Brun2b920a12010-09-23 18:30:22 +0200209
Frédéric Lécaille39143342019-05-24 14:32:27 +0200210/* The maximum length of an encoded data length. */
211#define PEER_MSG_ENC_LENGTH_MAXLEN 5
212
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200213/* Minimum 64-bits value encoded with 2 bytes */
214#define PEER_ENC_2BYTES_MIN 0xf0 /* 0xf0 (or 240) */
215/* 3 bytes */
216#define PEER_ENC_3BYTES_MIN ((1ULL << 11) | PEER_ENC_2BYTES_MIN) /* 0x8f0 (or 2288) */
217/* 4 bytes */
218#define PEER_ENC_4BYTES_MIN ((1ULL << 18) | PEER_ENC_3BYTES_MIN) /* 0x408f0 (or 264432) */
219/* 5 bytes */
220#define PEER_ENC_5BYTES_MIN ((1ULL << 25) | PEER_ENC_4BYTES_MIN) /* 0x20408f0 (or 33818864) */
221/* 6 bytes */
222#define PEER_ENC_6BYTES_MIN ((1ULL << 32) | PEER_ENC_5BYTES_MIN) /* 0x1020408f0 (or 4328786160) */
223/* 7 bytes */
224#define PEER_ENC_7BYTES_MIN ((1ULL << 39) | PEER_ENC_6BYTES_MIN) /* 0x81020408f0 (or 554084600048) */
225/* 8 bytes */
226#define PEER_ENC_8BYTES_MIN ((1ULL << 46) | PEER_ENC_7BYTES_MIN) /* 0x4081020408f0 (or 70922828777712) */
227/* 9 bytes */
228#define PEER_ENC_9BYTES_MIN ((1ULL << 53) | PEER_ENC_8BYTES_MIN) /* 0x204081020408f0 (or 9078122083518704) */
229/* 10 bytes */
230#define PEER_ENC_10BYTES_MIN ((1ULL << 60) | PEER_ENC_9BYTES_MIN) /* 0x10204081020408f0 (or 1161999626690365680) */
231
232/* #7 bit used to detect the last byte to be encoded */
233#define PEER_ENC_STOP_BIT 7
234/* The byte minimum value with #7 bit set */
235#define PEER_ENC_STOP_BYTE (1 << PEER_ENC_STOP_BIT)
236/* The left most number of bits set for PEER_ENC_2BYTES_MIN */
237#define PEER_ENC_2BYTES_MIN_BITS 4
238
Frédéric Lécaille39143342019-05-24 14:32:27 +0200239#define PEER_MSG_HEADER_LEN 2
240
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200241#define PEER_STKT_CACHE_MAX_ENTRIES 128
242
Emeric Brun2b920a12010-09-23 18:30:22 +0200243/**********************************/
244/* Peer Session IO handler states */
245/**********************************/
246
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100247enum {
248 PEER_SESS_ST_ACCEPT = 0, /* Initial state for session create by an accept, must be zero! */
249 PEER_SESS_ST_GETVERSION, /* Validate supported protocol version */
250 PEER_SESS_ST_GETHOST, /* Validate host ID correspond to local host id */
251 PEER_SESS_ST_GETPEER, /* Validate peer ID correspond to a known remote peer id */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100252 /* after this point, data were possibly exchanged */
253 PEER_SESS_ST_SENDSUCCESS, /* Send ret code 200 (success) and wait for message */
254 PEER_SESS_ST_CONNECT, /* Initial state for session create on a connect, push presentation into buffer */
255 PEER_SESS_ST_GETSTATUS, /* Wait for the welcome message */
256 PEER_SESS_ST_WAITMSG, /* Wait for data messages */
257 PEER_SESS_ST_EXIT, /* Exit with status code */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200258 PEER_SESS_ST_ERRPROTO, /* Send error proto message before exit */
259 PEER_SESS_ST_ERRSIZE, /* Send error size message before exit */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100260 PEER_SESS_ST_END, /* Killed session */
261};
Emeric Brun2b920a12010-09-23 18:30:22 +0200262
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100263/***************************************************/
264/* Peer Session status code - part of the protocol */
265/***************************************************/
Emeric Brun2b920a12010-09-23 18:30:22 +0200266
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100267#define PEER_SESS_SC_CONNECTCODE 100 /* connect in progress */
268#define PEER_SESS_SC_CONNECTEDCODE 110 /* tcp connect success */
Emeric Brun2b920a12010-09-23 18:30:22 +0200269
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100270#define PEER_SESS_SC_SUCCESSCODE 200 /* accept or connect successful */
Emeric Brun2b920a12010-09-23 18:30:22 +0200271
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100272#define PEER_SESS_SC_TRYAGAIN 300 /* try again later */
Emeric Brun2b920a12010-09-23 18:30:22 +0200273
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100274#define PEER_SESS_SC_ERRPROTO 501 /* error protocol */
275#define PEER_SESS_SC_ERRVERSION 502 /* unknown protocol version */
276#define PEER_SESS_SC_ERRHOST 503 /* bad host name */
277#define PEER_SESS_SC_ERRPEER 504 /* unknown peer */
Emeric Brun2b920a12010-09-23 18:30:22 +0200278
279#define PEER_SESSION_PROTO_NAME "HAProxyS"
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200280#define PEER_MAJOR_VER 2
281#define PEER_MINOR_VER 1
282#define PEER_DWNGRD_MINOR_VER 0
Emeric Brun2b920a12010-09-23 18:30:22 +0200283
Willy Tarreau6254a922019-01-29 17:45:23 +0100284static size_t proto_len = sizeof(PEER_SESSION_PROTO_NAME) - 1;
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200285struct peers *cfg_peers = NULL;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200286static void peer_session_forceshutdown(struct peer *peer);
Emeric Brun2b920a12010-09-23 18:30:22 +0200287
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200288static struct ebpt_node *dcache_tx_insert(struct dcache *dc,
289 struct dcache_tx_entry *i);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200290static inline void flush_dcache(struct peer *peer);
291
Frédéric Lécailled8659352020-11-10 16:18:03 +0100292/* trace source and events */
293static void peers_trace(enum trace_level level, uint64_t mask,
294 const struct trace_source *src,
295 const struct ist where, const struct ist func,
296 const void *a1, const void *a2, const void *a3, const void *a4);
297
298static const struct trace_event peers_trace_events[] = {
299#define PEERS_EV_UPDTMSG (1 << 0)
300 { .mask = PEERS_EV_UPDTMSG, .name = "updtmsg", .desc = "update message received" },
301};
302
303static const struct name_desc peers_trace_lockon_args[4] = {
304 /* arg1 */ { /* already used by the connection */ },
305 /* arg2 */ { .name="peers", .desc="Peers protocol" },
306 /* arg3 */ { },
307 /* arg4 */ { }
308};
309
310static const struct name_desc peers_trace_decoding[] = {
311#define PEERS_VERB_CLEAN 1
312 { .name="clean", .desc="only user-friendly stuff, generally suitable for level \"user\"" },
313 { /* end */ }
314};
315
316
317struct trace_source trace_peers = {
318 .name = IST("peers"),
319 .desc = "Peers protocol",
320 .arg_def = TRC_ARG1_CONN, /* TRACE()'s first argument is always a connection */
321 .default_cb = peers_trace,
322 .known_events = peers_trace_events,
323 .lockon_args = peers_trace_lockon_args,
324 .decoding = peers_trace_decoding,
325 .report_events = ~0, /* report everything by default */
326};
327
328#define TRACE_SOURCE &trace_peers
329INITCALL1(STG_REGISTER, trace_register_source, TRACE_SOURCE);
330
331static void peers_trace(enum trace_level level, uint64_t mask,
332 const struct trace_source *src,
333 const struct ist where, const struct ist func,
334 const void *a1, const void *a2, const void *a3, const void *a4)
335{
336 if (mask & PEERS_EV_UPDTMSG) {
337 if (a2) {
338 const struct peer *peer = a2;
339
340 chunk_appendf(&trace_buf, " peer=%s", peer->id);
341 }
342 if (a3) {
343 const char *p = a3;
344
345 chunk_appendf(&trace_buf, " @%p", p);
346 }
347 if (a4) {
348 const size_t *val = a4;
349
350 chunk_appendf(&trace_buf, " %llu", (unsigned long long)*val);
351 }
352 }
353}
354
Frédéric Lécaille95679dc2019-04-15 10:25:27 +0200355static const char *statuscode_str(int statuscode)
356{
357 switch (statuscode) {
358 case PEER_SESS_SC_CONNECTCODE:
359 return "CONN";
360 case PEER_SESS_SC_CONNECTEDCODE:
361 return "HSHK";
362 case PEER_SESS_SC_SUCCESSCODE:
363 return "ESTA";
364 case PEER_SESS_SC_TRYAGAIN:
365 return "RETR";
366 case PEER_SESS_SC_ERRPROTO:
367 return "PROT";
368 case PEER_SESS_SC_ERRVERSION:
369 return "VERS";
370 case PEER_SESS_SC_ERRHOST:
371 return "NAME";
372 case PEER_SESS_SC_ERRPEER:
373 return "UNKN";
374 default:
375 return "NONE";
376 }
377}
378
Emeric Brun18928af2017-03-29 16:32:53 +0200379/* This function encode an uint64 to 'dynamic' length format.
380 The encoded value is written at address *str, and the
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500381 caller must assure that size after *str is large enough.
Emeric Brun18928af2017-03-29 16:32:53 +0200382 At return, the *str is set at the next Byte after then
383 encoded integer. The function returns then length of the
384 encoded integer in Bytes */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200385int intencode(uint64_t i, char **str) {
386 int idx = 0;
387 unsigned char *msg;
388
Emeric Brunb3971ab2015-05-12 18:49:09 +0200389 msg = (unsigned char *)*str;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200390 if (i < PEER_ENC_2BYTES_MIN) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200391 msg[0] = (unsigned char)i;
392 *str = (char *)&msg[idx+1];
393 return (idx+1);
394 }
395
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200396 msg[idx] =(unsigned char)i | PEER_ENC_2BYTES_MIN;
397 i = (i - PEER_ENC_2BYTES_MIN) >> PEER_ENC_2BYTES_MIN_BITS;
398 while (i >= PEER_ENC_STOP_BYTE) {
399 msg[++idx] = (unsigned char)i | PEER_ENC_STOP_BYTE;
400 i = (i - PEER_ENC_STOP_BYTE) >> PEER_ENC_STOP_BIT;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200401 }
402 msg[++idx] = (unsigned char)i;
403 *str = (char *)&msg[idx+1];
404 return (idx+1);
405}
406
407
408/* This function returns the decoded integer or 0
409 if decode failed
410 *str point on the beginning of the integer to decode
411 at the end of decoding *str point on the end of the
412 encoded integer or to null if end is reached */
Emeric Brun18928af2017-03-29 16:32:53 +0200413uint64_t intdecode(char **str, char *end)
414{
Emeric Brunb3971ab2015-05-12 18:49:09 +0200415 unsigned char *msg;
Emeric Brun18928af2017-03-29 16:32:53 +0200416 uint64_t i;
417 int shift;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200418
419 if (!*str)
420 return 0;
421
422 msg = (unsigned char *)*str;
Emeric Brun18928af2017-03-29 16:32:53 +0200423 if (msg >= (unsigned char *)end)
424 goto fail;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200425
Emeric Brun18928af2017-03-29 16:32:53 +0200426 i = *(msg++);
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200427 if (i >= PEER_ENC_2BYTES_MIN) {
428 shift = PEER_ENC_2BYTES_MIN_BITS;
Emeric Brun18928af2017-03-29 16:32:53 +0200429 do {
430 if (msg >= (unsigned char *)end)
431 goto fail;
432 i += (uint64_t)*msg << shift;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200433 shift += PEER_ENC_STOP_BIT;
434 } while (*(msg++) >= PEER_ENC_STOP_BYTE);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200435 }
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100436 *str = (char *)msg;
437 return i;
Emeric Brun18928af2017-03-29 16:32:53 +0200438
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100439 fail:
440 *str = NULL;
441 return 0;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200442}
Emeric Brun2b920a12010-09-23 18:30:22 +0200443
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100444/*
445 * Build a "hello" peer protocol message.
446 * Return the number of written bytes written to build this messages if succeeded,
447 * 0 if not.
448 */
449static int peer_prepare_hellomsg(char *msg, size_t size, struct peer_prep_params *p)
450{
451 int min_ver, ret;
452 struct peer *peer;
453
454 peer = p->hello.peer;
455 min_ver = (peer->flags & PEER_F_DWNGRD) ? PEER_DWNGRD_MINOR_VER : PEER_MINOR_VER;
456 /* Prepare headers */
457 ret = snprintf(msg, size, PEER_SESSION_PROTO_NAME " %u.%u\n%s\n%s %d %d\n",
458 PEER_MAJOR_VER, min_ver, peer->id, localpeer, (int)getpid(), relative_pid);
459 if (ret >= size)
460 return 0;
461
462 return ret;
463}
464
465/*
466 * Build a "handshake succeeded" status message.
467 * Return the number of written bytes written to build this messages if succeeded,
468 * 0 if not.
469 */
470static int peer_prepare_status_successmsg(char *msg, size_t size, struct peer_prep_params *p)
471{
472 int ret;
473
474 ret = snprintf(msg, size, "%d\n", PEER_SESS_SC_SUCCESSCODE);
475 if (ret >= size)
476 return 0;
477
478 return ret;
479}
480
481/*
482 * Build an error status message.
483 * Return the number of written bytes written to build this messages if succeeded,
484 * 0 if not.
485 */
486static int peer_prepare_status_errormsg(char *msg, size_t size, struct peer_prep_params *p)
487{
488 int ret;
489 unsigned int st1;
490
491 st1 = p->error_status.st1;
492 ret = snprintf(msg, size, "%d\n", st1);
493 if (ret >= size)
494 return 0;
495
496 return ret;
497}
498
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200499/* Set the stick-table UPDATE message type byte at <msg_type> address,
500 * depending on <use_identifier> and <use_timed> boolean parameters.
501 * Always successful.
502 */
503static inline void peer_set_update_msg_type(char *msg_type, int use_identifier, int use_timed)
504{
505 if (use_timed) {
506 if (use_identifier)
507 *msg_type = PEER_MSG_STKT_UPDATE_TIMED;
508 else
509 *msg_type = PEER_MSG_STKT_INCUPDATE_TIMED;
510 }
511 else {
512 if (use_identifier)
513 *msg_type = PEER_MSG_STKT_UPDATE;
514 else
515 *msg_type = PEER_MSG_STKT_INCUPDATE;
516 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200517}
Emeric Brun2b920a12010-09-23 18:30:22 +0200518/*
Emeric Brunb3971ab2015-05-12 18:49:09 +0200519 * This prepare the data update message on the stick session <ts>, <st> is the considered
520 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800521 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200522 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
523 * check size)
Emeric Brun2b920a12010-09-23 18:30:22 +0200524 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100525static int peer_prepare_updatemsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brun2b920a12010-09-23 18:30:22 +0200526{
527 uint32_t netinteger;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200528 unsigned short datalen;
529 char *cursor, *datamsg;
Emeric Brun94900952015-06-11 18:25:54 +0200530 unsigned int data_type;
531 void *data_ptr;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100532 struct stksess *ts;
533 struct shared_table *st;
534 unsigned int updateid;
535 int use_identifier;
536 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200537 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100538
539 ts = p->updt.stksess;
540 st = p->updt.shared_table;
541 updateid = p->updt.updateid;
542 use_identifier = p->updt.use_identifier;
543 use_timed = p->updt.use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200544 peer = p->updt.peer;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200545
Frédéric Lécaille0e8db972019-05-24 14:34:34 +0200546 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200547
Emeric Brun2b920a12010-09-23 18:30:22 +0200548 /* construct message */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200549
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500550 /* check if we need to send the update identifier */
Emeric Brun819fc6f2017-06-13 19:37:32 +0200551 if (!st->last_pushed || updateid < st->last_pushed || ((updateid - st->last_pushed) != 1)) {
Emeric Bruna6a09982015-09-22 15:34:19 +0200552 use_identifier = 1;
Emeric Brun2b920a12010-09-23 18:30:22 +0200553 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200554
555 /* encode update identifier if needed */
556 if (use_identifier) {
Emeric Brun819fc6f2017-06-13 19:37:32 +0200557 netinteger = htonl(updateid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200558 memcpy(cursor, &netinteger, sizeof(netinteger));
559 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200560 }
561
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200562 if (use_timed) {
563 netinteger = htonl(tick_remain(now_ms, ts->expire));
564 memcpy(cursor, &netinteger, sizeof(netinteger));
565 cursor += sizeof(netinteger);
566 }
567
Emeric Brunb3971ab2015-05-12 18:49:09 +0200568 /* encode the key */
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200569 if (st->table->type == SMP_T_STR) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200570 int stlen = strlen((char *)ts->key.key);
571
Emeric Brunb3971ab2015-05-12 18:49:09 +0200572 intencode(stlen, &cursor);
573 memcpy(cursor, ts->key.key, stlen);
574 cursor += stlen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200575 }
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200576 else if (st->table->type == SMP_T_SINT) {
Willy Tarreau6cde5d82020-02-25 09:41:22 +0100577 netinteger = htonl(read_u32(ts->key.key));
Emeric Brunb3971ab2015-05-12 18:49:09 +0200578 memcpy(cursor, &netinteger, sizeof(netinteger));
579 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200580 }
581 else {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200582 memcpy(cursor, ts->key.key, st->table->key_size);
583 cursor += st->table->key_size;
Emeric Brun2b920a12010-09-23 18:30:22 +0200584 }
585
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100586 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200587 /* encode values */
Emeric Brun94900952015-06-11 18:25:54 +0200588 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200589
Emeric Brun94900952015-06-11 18:25:54 +0200590 data_ptr = stktable_data_ptr(st->table, ts, data_type);
591 if (data_ptr) {
592 switch (stktable_data_types[data_type].std_type) {
593 case STD_T_SINT: {
594 int data;
595
596 data = stktable_data_cast(data_ptr, std_t_sint);
597 intencode(data, &cursor);
598 break;
599 }
600 case STD_T_UINT: {
601 unsigned int data;
602
603 data = stktable_data_cast(data_ptr, std_t_uint);
604 intencode(data, &cursor);
605 break;
606 }
607 case STD_T_ULL: {
608 unsigned long long data;
609
610 data = stktable_data_cast(data_ptr, std_t_ull);
611 intencode(data, &cursor);
612 break;
613 }
614 case STD_T_FRQP: {
615 struct freq_ctr_period *frqp;
616
617 frqp = &stktable_data_cast(data_ptr, std_t_frqp);
618 intencode((unsigned int)(now_ms - frqp->curr_tick), &cursor);
619 intencode(frqp->curr_ctr, &cursor);
620 intencode(frqp->prev_ctr, &cursor);
621 break;
622 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200623 case STD_T_DICT: {
624 struct dict_entry *de;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200625 struct ebpt_node *cached_de;
Willy Tarreau237f8ae2019-06-06 16:40:43 +0200626 struct dcache_tx_entry cde = { };
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200627 char *beg, *end;
628 size_t value_len, data_len;
629 struct dcache *dc;
630
631 de = stktable_data_cast(data_ptr, std_t_dict);
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100632 if (!de) {
633 /* No entry */
634 intencode(0, &cursor);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200635 break;
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100636 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200637
638 dc = peer->dcache;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200639 cde.entry.key = de;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200640 cached_de = dcache_tx_insert(dc, &cde);
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200641 if (cached_de == &cde.entry) {
642 if (cde.id + 1 >= PEER_ENC_2BYTES_MIN)
643 break;
644 /* Encode the length of the remaining data -> 1 */
645 intencode(1, &cursor);
646 /* Encode the cache entry ID */
647 intencode(cde.id + 1, &cursor);
648 }
649 else {
650 /* Leave enough room to encode the remaining data length. */
651 end = beg = cursor + PEER_MSG_ENC_LENGTH_MAXLEN;
652 /* Encode the dictionary entry key */
653 intencode(cde.id + 1, &end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200654 /* Encode the length of the dictionary entry data */
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200655 value_len = de->len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200656 intencode(value_len, &end);
657 /* Copy the data */
658 memcpy(end, de->value.key, value_len);
659 end += value_len;
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200660 /* Encode the length of the data */
661 data_len = end - beg;
662 intencode(data_len, &cursor);
663 memmove(cursor, beg, data_len);
664 cursor += data_len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200665 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200666 break;
667 }
Emeric Brun94900952015-06-11 18:25:54 +0200668 }
669 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200670 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100671 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200672
673 /* Compute datalen */
674 datalen = (cursor - datamsg);
675
676 /* prepare message header */
677 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200678 peer_set_update_msg_type(&msg[1], use_identifier, use_timed);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200679 cursor = &msg[2];
680 intencode(datalen, &cursor);
681
682 /* move data after header */
683 memmove(cursor, datamsg, datalen);
684
685 /* return header size + data_len */
686 return (cursor - msg) + datalen;
687}
688
689/*
690 * This prepare the switch table message to targeted share table <st>.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800691 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200692 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
693 * check size)
694 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100695static int peer_prepare_switchmsg(char *msg, size_t size, struct peer_prep_params *params)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200696{
697 int len;
698 unsigned short datalen;
Willy Tarreau83061a82018-07-13 11:56:34 +0200699 struct buffer *chunk;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200700 char *cursor, *datamsg, *chunkp, *chunkq;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200701 uint64_t data = 0;
Emeric Brun94900952015-06-11 18:25:54 +0200702 unsigned int data_type;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100703 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200704
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100705 st = params->swtch.shared_table;
Frédéric Lécaille39143342019-05-24 14:32:27 +0200706 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200707
708 /* Encode data */
709
710 /* encode local id */
711 intencode(st->local_id, &cursor);
712
713 /* encode table name */
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100714 len = strlen(st->table->nid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200715 intencode(len, &cursor);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100716 memcpy(cursor, st->table->nid, len);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200717 cursor += len;
718
719 /* encode table type */
720
Emeric Brun530ba382020-06-02 11:17:42 +0200721 intencode(peer_net_key_type[st->table->type], &cursor);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200722
723 /* encode table key size */
724 intencode(st->table->key_size, &cursor);
725
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200726 chunk = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200727 chunkp = chunkq = chunk->area;
Emeric Brun94900952015-06-11 18:25:54 +0200728 /* encode available known data types in table */
729 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
730 if (st->table->data_ofs[data_type]) {
731 switch (stktable_data_types[data_type].std_type) {
732 case STD_T_SINT:
733 case STD_T_UINT:
734 case STD_T_ULL:
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200735 case STD_T_DICT:
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200736 data |= 1 << data_type;
737 break;
Emeric Brun94900952015-06-11 18:25:54 +0200738 case STD_T_FRQP:
739 data |= 1 << data_type;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200740 intencode(data_type, &chunkq);
741 intencode(st->table->data_arg[data_type].u, &chunkq);
Emeric Brun94900952015-06-11 18:25:54 +0200742 break;
743 }
744 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200745 }
746 intencode(data, &cursor);
747
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200748 /* Encode stick-table entries duration. */
749 intencode(st->table->expire, &cursor);
750
751 if (chunkq > chunkp) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200752 chunk->data = chunkq - chunkp;
753 memcpy(cursor, chunk->area, chunk->data);
754 cursor += chunk->data;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200755 }
756
Emeric Brunb3971ab2015-05-12 18:49:09 +0200757 /* Compute datalen */
758 datalen = (cursor - datamsg);
Emeric Brun2b920a12010-09-23 18:30:22 +0200759
Emeric Brunb3971ab2015-05-12 18:49:09 +0200760 /* prepare message header */
761 msg[0] = PEER_MSG_CLASS_STICKTABLE;
762 msg[1] = PEER_MSG_STKT_DEFINE;
763 cursor = &msg[2];
764 intencode(datalen, &cursor);
Emeric Brun2b920a12010-09-23 18:30:22 +0200765
Emeric Brunb3971ab2015-05-12 18:49:09 +0200766 /* move data after header */
767 memmove(cursor, datamsg, datalen);
768
769 /* return header size + data_len */
770 return (cursor - msg) + datalen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200771}
772
Emeric Brunb3971ab2015-05-12 18:49:09 +0200773/*
774 * This prepare the acknowledge message on the stick session <ts>, <st> is the considered
775 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800776 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200777 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
778 * check size)
779 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100780static int peer_prepare_ackmsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200781{
782 unsigned short datalen;
783 char *cursor, *datamsg;
784 uint32_t netinteger;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100785 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200786
Frédéric Lécaille39143342019-05-24 14:32:27 +0200787 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200788
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100789 st = p->ack.shared_table;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200790 intencode(st->remote_id, &cursor);
791 netinteger = htonl(st->last_get);
792 memcpy(cursor, &netinteger, sizeof(netinteger));
793 cursor += sizeof(netinteger);
794
795 /* Compute datalen */
796 datalen = (cursor - datamsg);
797
798 /* prepare message header */
799 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Emeric Brune1ab8082015-08-21 11:48:54 +0200800 msg[1] = PEER_MSG_STKT_ACK;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200801 cursor = &msg[2];
802 intencode(datalen, &cursor);
803
804 /* move data after header */
805 memmove(cursor, datamsg, datalen);
806
807 /* return header size + data_len */
808 return (cursor - msg) + datalen;
809}
Emeric Brun2b920a12010-09-23 18:30:22 +0200810
811/*
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200812 * Function to deinit connected peer
813 */
814void __peer_session_deinit(struct peer *peer)
815{
816 struct stream_interface *si;
817 struct stream *s;
818 struct peers *peers;
819
820 if (!peer->appctx)
821 return;
822
823 si = peer->appctx->owner;
824 if (!si)
825 return;
826
827 s = si_strm(si);
828 if (!s)
829 return;
830
831 peers = strm_fe(s)->parent;
832 if (!peers)
833 return;
834
835 if (peer->appctx->st0 == PEER_SESS_ST_WAITMSG)
836 HA_ATOMIC_SUB(&connected_peers, 1);
837
838 HA_ATOMIC_SUB(&active_peers, 1);
839
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200840 flush_dcache(peer);
841
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200842 /* Re-init current table pointers to force announcement on re-connect */
843 peer->remote_table = peer->last_local_table = NULL;
844 peer->appctx = NULL;
845 if (peer->flags & PEER_F_LEARN_ASSIGN) {
846 /* unassign current peer for learning */
847 peer->flags &= ~(PEER_F_LEARN_ASSIGN);
848 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
849
850 /* reschedule a resync */
851 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
852 }
853 /* reset teaching and learning flags to 0 */
854 peer->flags &= PEER_TEACH_RESET;
855 peer->flags &= PEER_LEARN_RESET;
856 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
857}
858
859/*
Emeric Brun2b920a12010-09-23 18:30:22 +0200860 * Callback to release a session with a peer
861 */
Willy Tarreau00a37f02015-04-13 12:05:19 +0200862static void peer_session_release(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +0200863{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200864 struct peer *peer = appctx->ctx.peers.ptr;
Emeric Brun2b920a12010-09-23 18:30:22 +0200865
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100866 /* appctx->ctx.peers.ptr is not a peer session */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100867 if (appctx->st0 < PEER_SESS_ST_SENDSUCCESS)
Emeric Brun2b920a12010-09-23 18:30:22 +0200868 return;
869
870 /* peer session identified */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200871 if (peer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100872 HA_SPIN_LOCK(PEER_LOCK, &peer->lock);
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200873 if (peer->appctx == appctx)
874 __peer_session_deinit(peer);
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +0200875 peer->flags &= ~PEER_F_ALIVE;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100876 HA_SPIN_UNLOCK(PEER_LOCK, &peer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +0200877 }
878}
879
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200880/* Retrieve the major and minor versions of peers protocol
881 * announced by a remote peer. <str> is a null-terminated
882 * string with the following format: "<maj_ver>.<min_ver>".
883 */
884static int peer_get_version(const char *str,
885 unsigned int *maj_ver, unsigned int *min_ver)
886{
887 unsigned int majv, minv;
888 const char *pos, *saved;
889 const char *end;
890
891 saved = pos = str;
892 end = str + strlen(str);
893
894 majv = read_uint(&pos, end);
895 if (saved == pos || *pos++ != '.')
896 return -1;
897
898 saved = pos;
899 minv = read_uint(&pos, end);
900 if (saved == pos || pos != end)
901 return -1;
902
903 *maj_ver = majv;
904 *min_ver = minv;
905
906 return 0;
907}
Emeric Brun2b920a12010-09-23 18:30:22 +0200908
909/*
Frédéric Lécaillece025572019-01-21 13:38:06 +0100910 * Parse a line terminated by an optional '\r' character, followed by a mandatory
911 * '\n' character.
912 * Returns 1 if succeeded or 0 if a '\n' character could not be found, and -1 if
913 * a line could not be read because the communication channel is closed.
914 */
915static inline int peer_getline(struct appctx *appctx)
916{
917 int n;
918 struct stream_interface *si = appctx->owner;
919
920 n = co_getline(si_oc(si), trash.area, trash.size);
921 if (!n)
922 return 0;
923
924 if (n < 0 || trash.area[n - 1] != '\n') {
925 appctx->st0 = PEER_SESS_ST_END;
926 return -1;
927 }
928
929 if (n > 1 && (trash.area[n - 2] == '\r'))
930 trash.area[n - 2] = 0;
931 else
932 trash.area[n - 1] = 0;
933
934 co_skip(si_oc(si), n);
935
936 return n;
937}
938
939/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100940 * Send a message after having called <peer_prepare_msg> to build it.
941 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
942 * Returns -1 if there was not enough room left to send the message,
943 * any other negative returned value must be considered as an error with an appcxt st0
944 * returned value equal to PEER_SESS_ST_END.
945 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100946static inline int peer_send_msg(struct appctx *appctx,
947 int (*peer_prepare_msg)(char *, size_t, struct peer_prep_params *),
948 struct peer_prep_params *params)
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100949{
950 int ret, msglen;
951 struct stream_interface *si = appctx->owner;
952
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100953 msglen = peer_prepare_msg(trash.area, trash.size, params);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100954 if (!msglen) {
955 /* internal error: message does not fit in trash */
956 appctx->st0 = PEER_SESS_ST_END;
957 return 0;
958 }
959
960 /* message to buffer */
961 ret = ci_putblk(si_ic(si), trash.area, msglen);
962 if (ret <= 0) {
963 if (ret == -1) {
964 /* No more write possible */
965 si_rx_room_blk(si);
966 return -1;
967 }
968 appctx->st0 = PEER_SESS_ST_END;
969 }
970
971 return ret;
972}
973
974/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100975 * Send a hello message.
976 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
977 * Returns -1 if there was not enough room left to send the message,
978 * any other negative returned value must be considered as an error with an appcxt st0
979 * returned value equal to PEER_SESS_ST_END.
980 */
981static inline int peer_send_hellomsg(struct appctx *appctx, struct peer *peer)
982{
983 struct peer_prep_params p = {
984 .hello.peer = peer,
985 };
986
987 return peer_send_msg(appctx, peer_prepare_hellomsg, &p);
988}
989
990/*
991 * Send a success peer handshake status message.
992 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
993 * Returns -1 if there was not enough room left to send the message,
994 * any other negative returned value must be considered as an error with an appcxt st0
995 * returned value equal to PEER_SESS_ST_END.
996 */
997static inline int peer_send_status_successmsg(struct appctx *appctx)
998{
999 return peer_send_msg(appctx, peer_prepare_status_successmsg, NULL);
1000}
1001
1002/*
1003 * Send a peer handshake status error message.
1004 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1005 * Returns -1 if there was not enough room left to send the message,
1006 * any other negative returned value must be considered as an error with an appcxt st0
1007 * returned value equal to PEER_SESS_ST_END.
1008 */
1009static inline int peer_send_status_errormsg(struct appctx *appctx)
1010{
1011 struct peer_prep_params p = {
1012 .error_status.st1 = appctx->st1,
1013 };
1014
1015 return peer_send_msg(appctx, peer_prepare_status_errormsg, &p);
1016}
1017
1018/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001019 * Send a stick-table switch message.
1020 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1021 * Returns -1 if there was not enough room left to send the message,
1022 * any other negative returned value must be considered as an error with an appcxt st0
1023 * returned value equal to PEER_SESS_ST_END.
1024 */
1025static inline int peer_send_switchmsg(struct shared_table *st, struct appctx *appctx)
1026{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001027 struct peer_prep_params p = {
1028 .swtch.shared_table = st,
1029 };
1030
1031 return peer_send_msg(appctx, peer_prepare_switchmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001032}
1033
1034/*
1035 * Send a stick-table update acknowledgement message.
1036 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1037 * Returns -1 if there was not enough room left to send the message,
1038 * any other negative returned value must be considered as an error with an appcxt st0
1039 * returned value equal to PEER_SESS_ST_END.
1040 */
1041static inline int peer_send_ackmsg(struct shared_table *st, struct appctx *appctx)
1042{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001043 struct peer_prep_params p = {
1044 .ack.shared_table = st,
1045 };
1046
1047 return peer_send_msg(appctx, peer_prepare_ackmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +01001048}
1049
1050/*
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001051 * Send a stick-table update message.
1052 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1053 * Returns -1 if there was not enough room left to send the message,
1054 * any other negative returned value must be considered as an error with an appcxt st0
1055 * returned value equal to PEER_SESS_ST_END.
1056 */
1057static inline int peer_send_updatemsg(struct shared_table *st, struct appctx *appctx, struct stksess *ts,
1058 unsigned int updateid, int use_identifier, int use_timed)
1059{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001060 struct peer_prep_params p = {
Willy Tarreaua898f0c2020-07-03 19:09:29 +02001061 .updt = {
1062 .stksess = ts,
1063 .shared_table = st,
1064 .updateid = updateid,
1065 .use_identifier = use_identifier,
1066 .use_timed = use_timed,
1067 .peer = appctx->ctx.peers.ptr,
1068 },
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +01001069 };
1070
1071 return peer_send_msg(appctx, peer_prepare_updatemsg, &p);
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001072}
1073
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001074/*
1075 * Build a peer protocol control class message.
1076 * Returns the number of written bytes used to build the message if succeeded,
1077 * 0 if not.
1078 */
1079static int peer_prepare_control_msg(char *msg, size_t size, struct peer_prep_params *p)
1080{
1081 if (size < sizeof p->control.head)
1082 return 0;
1083
1084 msg[0] = p->control.head[0];
1085 msg[1] = p->control.head[1];
1086
1087 return 2;
1088}
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001089
1090/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001091 * Send a stick-table synchronization request message.
1092 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1093 * Returns -1 if there was not enough room left to send the message,
1094 * any other negative returned value must be considered as an error with an appctx st0
1095 * returned value equal to PEER_SESS_ST_END.
1096 */
1097static inline int peer_send_resync_reqmsg(struct appctx *appctx)
1098{
1099 struct peer_prep_params p = {
1100 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCREQ, },
1101 };
1102
1103 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1104}
1105
1106/*
1107 * Send a stick-table synchronization confirmation message.
1108 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1109 * Returns -1 if there was not enough room left to send the message,
1110 * any other negative returned value must be considered as an error with an appctx st0
1111 * returned value equal to PEER_SESS_ST_END.
1112 */
1113static inline int peer_send_resync_confirmsg(struct appctx *appctx)
1114{
1115 struct peer_prep_params p = {
1116 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCCONFIRM, },
1117 };
1118
1119 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1120}
1121
1122/*
1123 * Send a stick-table synchronization finished message.
1124 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1125 * Returns -1 if there was not enough room left to send the message,
1126 * any other negative returned value must be considered as an error with an appctx st0
1127 * returned value equal to PEER_SESS_ST_END.
1128 */
Emeric Brun70de43b2020-03-16 10:51:01 +01001129static inline int peer_send_resync_finishedmsg(struct appctx *appctx, struct peers *peers)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001130{
1131 struct peer_prep_params p = {
1132 .control.head = { PEER_MSG_CLASS_CONTROL, },
1133 };
1134
Emeric Brun70de43b2020-03-16 10:51:01 +01001135 p.control.head[1] = (peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED ?
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001136 PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
1137
1138 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1139}
1140
1141/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001142 * Send a heartbeat message.
1143 * Return 0 if the message could not be built modifying the appctx st0 to PEER_SESS_ST_END value.
1144 * Returns -1 if there was not enough room left to send the message,
1145 * any other negative returned value must be considered as an error with an appctx st0
1146 * returned value equal to PEER_SESS_ST_END.
1147 */
1148static inline int peer_send_heartbeatmsg(struct appctx *appctx)
1149{
1150 struct peer_prep_params p = {
1151 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_HEARTBEAT, },
1152 };
1153
1154 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1155}
1156
1157/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001158 * Build a peer protocol error class message.
1159 * Returns the number of written bytes used to build the message if succeeded,
1160 * 0 if not.
1161 */
1162static int peer_prepare_error_msg(char *msg, size_t size, struct peer_prep_params *p)
1163{
1164 if (size < sizeof p->error.head)
1165 return 0;
1166
1167 msg[0] = p->error.head[0];
1168 msg[1] = p->error.head[1];
1169
1170 return 2;
1171}
1172
1173/*
1174 * Send a "size limit reached" error message.
1175 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1176 * Returns -1 if there was not enough room left to send the message,
1177 * any other negative returned value must be considered as an error with an appctx st0
1178 * returned value equal to PEER_SESS_ST_END.
1179 */
1180static inline int peer_send_error_size_limitmsg(struct appctx *appctx)
1181{
1182 struct peer_prep_params p = {
1183 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_SIZELIMIT, },
1184 };
1185
1186 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1187}
1188
1189/*
1190 * Send a "peer protocol" error message.
1191 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1192 * Returns -1 if there was not enough room left to send the message,
1193 * any other negative returned value must be considered as an error with an appctx st0
1194 * returned value equal to PEER_SESS_ST_END.
1195 */
1196static inline int peer_send_error_protomsg(struct appctx *appctx)
1197{
1198 struct peer_prep_params p = {
1199 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_PROTOCOL, },
1200 };
1201
1202 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1203}
1204
1205/*
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001206 * Function used to lookup for recent stick-table updates associated with
1207 * <st> shared stick-table when a lesson must be taught a peer (PEER_F_LEARN_ASSIGN flag set).
1208 */
1209static inline struct stksess *peer_teach_process_stksess_lookup(struct shared_table *st)
1210{
1211 struct eb32_node *eb;
1212
1213 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1214 if (!eb) {
1215 eb = eb32_first(&st->table->updates);
1216 if (!eb || ((int)(eb->key - st->last_pushed) <= 0)) {
1217 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1218 return NULL;
1219 }
1220 }
1221
1222 if ((int)(eb->key - st->table->localupdate) > 0) {
1223 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1224 return NULL;
1225 }
1226
1227 return eb32_entry(eb, struct stksess, upd);
1228}
1229
1230/*
1231 * Function used to lookup for recent stick-table updates associated with
1232 * <st> shared stick-table during teach state 1 step.
1233 */
1234static inline struct stksess *peer_teach_stage1_stksess_lookup(struct shared_table *st)
1235{
1236 struct eb32_node *eb;
1237
1238 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1239 if (!eb) {
1240 st->flags |= SHTABLE_F_TEACH_STAGE1;
1241 eb = eb32_first(&st->table->updates);
1242 if (eb)
1243 st->last_pushed = eb->key - 1;
1244 return NULL;
1245 }
1246
1247 return eb32_entry(eb, struct stksess, upd);
1248}
1249
1250/*
1251 * Function used to lookup for recent stick-table updates associated with
1252 * <st> shared stick-table during teach state 2 step.
1253 */
1254static inline struct stksess *peer_teach_stage2_stksess_lookup(struct shared_table *st)
1255{
1256 struct eb32_node *eb;
1257
1258 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1259 if (!eb || eb->key > st->teaching_origin) {
1260 st->flags |= SHTABLE_F_TEACH_STAGE2;
1261 return NULL;
1262 }
1263
1264 return eb32_entry(eb, struct stksess, upd);
1265}
1266
1267/*
1268 * Generic function to emit update messages for <st> stick-table when a lesson must
1269 * be taught to the peer <p>.
1270 * <locked> must be set to 1 if the shared table <st> is already locked when entering
1271 * this function, 0 if not.
1272 *
1273 * This function temporary unlock/lock <st> when it sends stick-table updates or
1274 * when decrementing its refcount in case of any error when it sends this updates.
1275 *
1276 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1277 * Returns -1 if there was not enough room left to send the message,
1278 * any other negative returned value must be considered as an error with an appcxt st0
1279 * returned value equal to PEER_SESS_ST_END.
1280 * If it returns 0 or -1, this function leave <st> locked if already locked when entering this function
1281 * unlocked if not already locked when entering this function.
1282 */
1283static inline int peer_send_teachmsgs(struct appctx *appctx, struct peer *p,
1284 struct stksess *(*peer_stksess_lookup)(struct shared_table *),
1285 struct shared_table *st, int locked)
1286{
1287 int ret, new_pushed, use_timed;
1288
1289 ret = 1;
1290 use_timed = 0;
1291 if (st != p->last_local_table) {
1292 ret = peer_send_switchmsg(st, appctx);
1293 if (ret <= 0)
1294 return ret;
1295
1296 p->last_local_table = st;
1297 }
1298
1299 if (peer_stksess_lookup != peer_teach_process_stksess_lookup)
1300 use_timed = !(p->flags & PEER_F_DWNGRD);
1301
1302 /* We force new pushed to 1 to force identifier in update message */
1303 new_pushed = 1;
1304
1305 if (!locked)
1306 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1307
1308 while (1) {
1309 struct stksess *ts;
1310 unsigned updateid;
1311
1312 /* push local updates */
1313 ts = peer_stksess_lookup(st);
1314 if (!ts)
1315 break;
1316
1317 updateid = ts->upd.key;
1318 ts->ref_cnt++;
1319 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1320
1321 ret = peer_send_updatemsg(st, appctx, ts, updateid, new_pushed, use_timed);
1322 if (ret <= 0) {
1323 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1324 ts->ref_cnt--;
1325 if (!locked)
1326 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1327 return ret;
1328 }
1329
1330 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1331 ts->ref_cnt--;
1332 st->last_pushed = updateid;
1333
1334 if (peer_stksess_lookup == peer_teach_process_stksess_lookup &&
1335 (int)(st->last_pushed - st->table->commitupdate) > 0)
1336 st->table->commitupdate = st->last_pushed;
1337
1338 /* identifier may not needed in next update message */
1339 new_pushed = 0;
1340 }
1341
1342 out:
1343 if (!locked)
1344 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1345 return 1;
1346}
1347
1348/*
1349 * Function to emit update messages for <st> stick-table when a lesson must
1350 * be taught to the peer <p> (PEER_F_LEARN_ASSIGN flag set).
1351 *
1352 * Note that <st> shared stick-table is locked when calling this function.
1353 *
1354 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1355 * Returns -1 if there was not enough room left to send the message,
1356 * any other negative returned value must be considered as an error with an appcxt st0
1357 * returned value equal to PEER_SESS_ST_END.
1358 */
1359static inline int peer_send_teach_process_msgs(struct appctx *appctx, struct peer *p,
1360 struct shared_table *st)
1361{
1362 return peer_send_teachmsgs(appctx, p, peer_teach_process_stksess_lookup, st, 1);
1363}
1364
1365/*
1366 * Function to emit update messages for <st> stick-table when a lesson must
1367 * be taught to the peer <p> during teach state 1 step.
1368 *
1369 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1370 * Returns -1 if there was not enough room left to send the message,
1371 * any other negative returned value must be considered as an error with an appcxt st0
1372 * returned value equal to PEER_SESS_ST_END.
1373 */
1374static inline int peer_send_teach_stage1_msgs(struct appctx *appctx, struct peer *p,
1375 struct shared_table *st)
1376{
1377 return peer_send_teachmsgs(appctx, p, peer_teach_stage1_stksess_lookup, st, 0);
1378}
1379
1380/*
1381 * Function to emit update messages for <st> stick-table when a lesson must
1382 * be taught to the peer <p> during teach state 1 step.
1383 *
1384 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1385 * Returns -1 if there was not enough room left to send the message,
1386 * any other negative returned value must be considered as an error with an appcxt st0
1387 * returned value equal to PEER_SESS_ST_END.
1388 */
1389static inline int peer_send_teach_stage2_msgs(struct appctx *appctx, struct peer *p,
1390 struct shared_table *st)
1391{
1392 return peer_send_teachmsgs(appctx, p, peer_teach_stage2_stksess_lookup, st, 0);
1393}
1394
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001395
1396/*
1397 * Function used to parse a stick-table update message after it has been received
1398 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1399 * receipt buffer with <msg_end> being position of the end of the stick-table message.
1400 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1401 * was encountered.
1402 * <exp> must be set if the stick-table entry expires.
1403 * <updt> must be set for PEER_MSG_STKT_UPDATE or PEER_MSG_STKT_UPDATE_TIMED stick-table
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001404 * 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 +01001405 * update ID.
1406 * <totl> is the length of the stick-table update message computed upon receipt.
1407 */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001408static int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int exp,
1409 char **msg_cur, char *msg_end, int msg_len, int totl)
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001410{
1411 struct stream_interface *si = appctx->owner;
1412 struct shared_table *st = p->remote_table;
1413 struct stksess *ts, *newts;
1414 uint32_t update;
1415 int expire;
1416 unsigned int data_type;
1417 void *data_ptr;
1418
Frédéric Lécailled8659352020-11-10 16:18:03 +01001419 TRACE_ENTER(PEERS_EV_UPDTMSG, NULL, p);
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001420 /* Here we have data message */
1421 if (!st)
1422 goto ignore_msg;
1423
1424 expire = MS_TO_TICKS(st->table->expire);
1425
1426 if (updt) {
Frédéric Lécailled8659352020-11-10 16:18:03 +01001427 if (msg_len < sizeof(update)) {
1428 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001429 goto malformed_exit;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001430 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001431
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001432 memcpy(&update, *msg_cur, sizeof(update));
1433 *msg_cur += sizeof(update);
1434 st->last_get = htonl(update);
1435 }
1436 else {
1437 st->last_get++;
1438 }
1439
1440 if (exp) {
1441 size_t expire_sz = sizeof expire;
1442
Frédéric Lécailled8659352020-11-10 16:18:03 +01001443 if (*msg_cur + expire_sz > msg_end) {
1444 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1445 NULL, p, *msg_cur);
1446 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1447 NULL, p, msg_end, &expire_sz);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001448 goto malformed_exit;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001449 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001450
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001451 memcpy(&expire, *msg_cur, expire_sz);
1452 *msg_cur += expire_sz;
1453 expire = ntohl(expire);
1454 }
1455
1456 newts = stksess_new(st->table, NULL);
1457 if (!newts)
1458 goto ignore_msg;
1459
1460 if (st->table->type == SMP_T_STR) {
1461 unsigned int to_read, to_store;
1462
1463 to_read = intdecode(msg_cur, msg_end);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001464 if (!*msg_cur) {
1465 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001466 goto malformed_free_newts;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001467 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001468
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001469 to_store = MIN(to_read, st->table->key_size - 1);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001470 if (*msg_cur + to_store > msg_end) {
1471 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1472 NULL, p, *msg_cur);
1473 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1474 NULL, p, msg_end, &to_store);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001475 goto malformed_free_newts;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001476 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001477
1478 memcpy(newts->key.key, *msg_cur, to_store);
1479 newts->key.key[to_store] = 0;
1480 *msg_cur += to_read;
1481 }
1482 else if (st->table->type == SMP_T_SINT) {
1483 unsigned int netinteger;
1484
Frédéric Lécailled8659352020-11-10 16:18:03 +01001485 if (*msg_cur + sizeof(netinteger) > msg_end) {
1486 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1487 NULL, p, *msg_cur);
1488 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1489 NULL, p, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001490 goto malformed_free_newts;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001491 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001492
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001493 memcpy(&netinteger, *msg_cur, sizeof(netinteger));
1494 netinteger = ntohl(netinteger);
1495 memcpy(newts->key.key, &netinteger, sizeof(netinteger));
1496 *msg_cur += sizeof(netinteger);
1497 }
1498 else {
Frédéric Lécailled8659352020-11-10 16:18:03 +01001499 if (*msg_cur + st->table->key_size > msg_end) {
1500 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1501 NULL, p, *msg_cur);
1502 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1503 NULL, p, msg_end, &st->table->key_size);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001504 goto malformed_free_newts;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001505 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001506
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001507 memcpy(newts->key.key, *msg_cur, st->table->key_size);
1508 *msg_cur += st->table->key_size;
1509 }
1510
1511 /* lookup for existing entry */
1512 ts = stktable_set_entry(st->table, newts);
1513 if (ts != newts) {
1514 stksess_free(st->table, newts);
1515 newts = NULL;
1516 }
1517
1518 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
1519
1520 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001521 uint64_t decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001522
1523 if (!((1 << data_type) & st->remote_data))
1524 continue;
1525
Willy Tarreau1e82a142019-01-29 11:08:06 +01001526 decoded_int = intdecode(msg_cur, msg_end);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001527 if (!*msg_cur) {
1528 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001529 goto malformed_unlock;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001530 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001531
Willy Tarreau1e82a142019-01-29 11:08:06 +01001532 switch (stktable_data_types[data_type].std_type) {
1533 case STD_T_SINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001534 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1535 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001536 stktable_data_cast(data_ptr, std_t_sint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001537 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001538
Willy Tarreau1e82a142019-01-29 11:08:06 +01001539 case STD_T_UINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001540 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1541 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001542 stktable_data_cast(data_ptr, std_t_uint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001543 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001544
Willy Tarreau1e82a142019-01-29 11:08:06 +01001545 case STD_T_ULL:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001546 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1547 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001548 stktable_data_cast(data_ptr, std_t_ull) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001549 break;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001550
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001551 case STD_T_FRQP: {
1552 struct freq_ctr_period data;
1553
1554 /* First bit is reserved for the freq_ctr_period lock
1555 Note: here we're still protected by the stksess lock
1556 so we don't need to update the update the freq_ctr_period
1557 using its internal lock */
1558
Willy Tarreau1e82a142019-01-29 11:08:06 +01001559 data.curr_tick = tick_add(now_ms, -decoded_int) & ~0x1;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001560 data.curr_ctr = intdecode(msg_cur, msg_end);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001561 if (!*msg_cur) {
1562 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001563 goto malformed_unlock;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001564 }
Willy Tarreau1e82a142019-01-29 11:08:06 +01001565
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001566 data.prev_ctr = intdecode(msg_cur, msg_end);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001567 if (!*msg_cur) {
1568 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG, NULL, p);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001569 goto malformed_unlock;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001570 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001571
1572 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1573 if (data_ptr)
1574 stktable_data_cast(data_ptr, std_t_frqp) = data;
1575 break;
1576 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001577 case STD_T_DICT: {
1578 struct buffer *chunk;
1579 size_t data_len, value_len;
1580 unsigned int id;
1581 struct dict_entry *de;
1582 struct dcache *dc;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001583 char *end;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001584
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +01001585 if (!decoded_int) {
1586 /* No entry. */
1587 break;
1588 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001589 data_len = decoded_int;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001590 if (*msg_cur + data_len > msg_end) {
1591 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1592 NULL, p, *msg_cur);
1593 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1594 NULL, p, msg_end, &data_len);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001595 goto malformed_unlock;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001596 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001597
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001598 /* Compute the end of the current data, <msg_end> being at the end of
1599 * the entire message.
1600 */
1601 end = *msg_cur + data_len;
1602 id = intdecode(msg_cur, end);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001603 if (!*msg_cur || !id) {
1604 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1605 NULL, p, *msg_cur, &id);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001606 goto malformed_unlock;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001607 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001608
1609 dc = p->dcache;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001610 if (*msg_cur == end) {
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001611 /* Dictionary entry key without value. */
Frédéric Lécaillef9e51be2020-11-12 19:53:11 +01001612 if (id > dc->max_entries) {
1613 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1614 NULL, p, NULL, &id);
1615 goto malformed_unlock;
1616 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001617 /* IDs sent over the network are numbered from 1. */
1618 de = dc->rx[id - 1].de;
1619 }
1620 else {
1621 chunk = get_trash_chunk();
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001622 value_len = intdecode(msg_cur, end);
1623 if (!*msg_cur || *msg_cur + value_len > end ||
Frédéric Lécailled8659352020-11-10 16:18:03 +01001624 unlikely(value_len + 1 >= chunk->size)) {
1625 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1626 NULL, p, *msg_cur, &value_len);
1627 TRACE_PROTO("malformed message", PEERS_EV_UPDTMSG,
1628 NULL, p, end, &chunk->size);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001629 goto malformed_unlock;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001630 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001631
1632 chunk_memcpy(chunk, *msg_cur, value_len);
1633 chunk->area[chunk->data] = '\0';
Frédéric Lécaille56aec0d2019-06-06 14:14:15 +02001634 *msg_cur += value_len;
1635
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001636 de = dict_insert(&server_name_dict, chunk->area);
1637 dc->rx[id - 1].de = de;
1638 }
1639 if (de) {
1640 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1641 if (data_ptr)
1642 stktable_data_cast(data_ptr, std_t_dict) = de;
1643 }
1644 break;
1645 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001646 }
1647 }
1648 /* Force new expiration */
1649 ts->expire = tick_add(now_ms, expire);
1650
1651 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1652 stktable_touch_remote(st->table, ts, 1);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001653 TRACE_LEAVE(PEERS_EV_UPDTMSG, NULL, p);
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001654 return 1;
1655
1656 ignore_msg:
1657 /* skip consumed message */
1658 co_skip(si_oc(si), totl);
Frédéric Lécailled8659352020-11-10 16:18:03 +01001659 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001660 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001661
1662 malformed_unlock:
1663 /* malformed message */
1664 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1665 stktable_touch_remote(st->table, ts, 1);
1666 appctx->st0 = PEER_SESS_ST_ERRPROTO;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001667 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001668 return 0;
1669
1670 malformed_free_newts:
1671 /* malformed message */
1672 stksess_free(st->table, newts);
1673 malformed_exit:
1674 appctx->st0 = PEER_SESS_ST_ERRPROTO;
Frédéric Lécailled8659352020-11-10 16:18:03 +01001675 TRACE_DEVEL("leaving in error", PEERS_EV_UPDTMSG);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001676 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001677}
1678
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001679/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001680 * Function used to parse a stick-table update acknowledgement message after it
1681 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1682 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1683 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1684 * was encountered.
1685 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1686 */
1687static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1688 char **msg_cur, char *msg_end)
1689{
1690 /* ack message */
1691 uint32_t table_id ;
1692 uint32_t update;
1693 struct shared_table *st;
1694
1695 table_id = intdecode(msg_cur, msg_end);
1696 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1697 /* malformed message */
1698 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1699 return 0;
1700 }
1701
1702 memcpy(&update, *msg_cur, sizeof(update));
1703 update = ntohl(update);
1704
1705 for (st = p->tables; st; st = st->next) {
1706 if (st->local_id == table_id) {
1707 st->update = update;
1708 break;
1709 }
1710 }
1711
1712 return 1;
1713}
1714
1715/*
1716 * Function used to parse a stick-table switch message after it has been received
1717 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1718 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1719 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1720 * was encountered.
1721 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1722 */
1723static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1724 char **msg_cur, char *msg_end)
1725{
1726 struct shared_table *st;
1727 int table_id;
1728
1729 table_id = intdecode(msg_cur, msg_end);
1730 if (!*msg_cur) {
1731 /* malformed message */
1732 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1733 return 0;
1734 }
1735
1736 p->remote_table = NULL;
1737 for (st = p->tables; st; st = st->next) {
1738 if (st->remote_id == table_id) {
1739 p->remote_table = st;
1740 break;
1741 }
1742 }
1743
1744 return 1;
1745}
1746
1747/*
1748 * Function used to parse a stick-table definition message after it has been received
1749 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1750 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1751 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1752 * was encountered.
1753 * <totl> is the length of the stick-table update message computed upon receipt.
1754 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1755 */
1756static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1757 char **msg_cur, char *msg_end, int totl)
1758{
1759 struct stream_interface *si = appctx->owner;
1760 int table_id_len;
1761 struct shared_table *st;
1762 int table_type;
1763 int table_keylen;
1764 int table_id;
1765 uint64_t table_data;
1766
1767 table_id = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001768 if (!*msg_cur)
1769 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001770
1771 table_id_len = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001772 if (!*msg_cur)
1773 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001774
1775 p->remote_table = NULL;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001776 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end)
1777 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001778
1779 for (st = p->tables; st; st = st->next) {
1780 /* Reset IDs */
1781 if (st->remote_id == table_id)
1782 st->remote_id = 0;
1783
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001784 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1785 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001786 p->remote_table = st;
1787 }
1788
1789 if (!p->remote_table)
1790 goto ignore_msg;
1791
1792 *msg_cur += table_id_len;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001793 if (*msg_cur >= msg_end)
1794 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001795
1796 table_type = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001797 if (!*msg_cur)
1798 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001799
1800 table_keylen = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001801 if (!*msg_cur)
1802 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001803
1804 table_data = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001805 if (!*msg_cur)
1806 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001807
Emeric Brun530ba382020-06-02 11:17:42 +02001808 if (p->remote_table->table->type != peer_int_key_type[table_type]
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001809 || p->remote_table->table->key_size != table_keylen) {
1810 p->remote_table = NULL;
1811 goto ignore_msg;
1812 }
1813
1814 p->remote_table->remote_data = table_data;
1815 p->remote_table->remote_id = table_id;
1816 return 1;
1817
1818 ignore_msg:
1819 co_skip(si_oc(si), totl);
1820 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001821
1822 malformed_exit:
1823 /* malformed message */
1824 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1825 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001826}
1827
1828/*
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001829 * Receive a stick-table message or pre-parse any other message.
1830 * The message's header will be sent into <msg_head> which must be at least
1831 * <msg_head_sz> bytes long (at least 7 to store 32-bit variable lengths).
1832 * The first two bytes are always read, and the rest is only read if the
1833 * first bytes indicate a stick-table message. If the message is a stick-table
1834 * message, the varint is decoded and the equivalent number of bytes will be
1835 * copied into the trash at trash.area. <totl> is incremented by the number of
1836 * bytes read EVEN IN CASE OF INCOMPLETE MESSAGES.
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001837 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1838 * -1 if there was an error updating the appctx state st0 accordingly.
1839 */
1840static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1841 uint32_t *msg_len, int *totl)
1842{
1843 int reql;
1844 struct stream_interface *si = appctx->owner;
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001845 char *cur;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001846
1847 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1848 if (reql <= 0) /* closed or EOL not found */
1849 goto incomplete;
1850
1851 *totl += reql;
1852
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001853 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001854 return 1;
1855
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001856 /* This is a stick-table message, let's go on */
1857
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001858 /* Read and Decode message length */
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001859 msg_head += *totl;
1860 msg_head_sz -= *totl;
1861 reql = co_data(si_oc(si)) - *totl;
1862 if (reql > msg_head_sz)
1863 reql = msg_head_sz;
1864
1865 reql = co_getblk(si_oc(si), msg_head, reql, *totl);
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001866 if (reql <= 0) /* closed */
1867 goto incomplete;
1868
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001869 cur = msg_head;
1870 *msg_len = intdecode(&cur, cur + reql);
1871 if (!cur) {
1872 /* the number is truncated, did we read enough ? */
1873 if (reql < msg_head_sz)
1874 goto incomplete;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001875
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001876 /* malformed message */
1877 TRACE_PROTO("malformed message: too large length encoding", PEERS_EV_UPDTMSG);
1878 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1879 return -1;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001880 }
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01001881 *totl += cur - msg_head;
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001882
1883 /* Read message content */
1884 if (*msg_len) {
1885 if (*msg_len > trash.size) {
1886 /* Status code is not success, abort */
1887 appctx->st0 = PEER_SESS_ST_ERRSIZE;
1888 return -1;
1889 }
1890
1891 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
1892 if (reql <= 0) /* closed */
1893 goto incomplete;
1894 *totl += reql;
1895 }
1896
1897 return 1;
1898
1899 incomplete:
1900 if (reql < 0) {
1901 /* there was an error */
1902 appctx->st0 = PEER_SESS_ST_END;
1903 return -1;
1904 }
1905
1906 return 0;
1907}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001908
1909/*
1910 * Treat the awaited message with <msg_head> as header.*
1911 * Return 1 if succeeded, 0 if not.
1912 */
1913static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
1914 char **msg_cur, char *msg_end, int msg_len, int totl)
1915{
1916 struct stream_interface *si = appctx->owner;
1917 struct stream *s = si_strm(si);
1918 struct peers *peers = strm_fe(s)->parent;
1919
1920 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
1921 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
1922 struct shared_table *st;
1923 /* Reset message: remote need resync */
1924
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001925 /* prepare tables for a global push */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001926 for (st = peer->tables; st; st = st->next) {
1927 st->teaching_origin = st->last_pushed = st->table->update;
1928 st->flags = 0;
1929 }
1930
1931 /* reset teaching flags to 0 */
1932 peer->flags &= PEER_TEACH_RESET;
1933
1934 /* flag to start to teach lesson */
1935 peer->flags |= PEER_F_TEACH_PROCESS;
1936 }
1937 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
1938 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1939 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1940 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1941 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
1942 }
1943 peer->confirm++;
1944 }
1945 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
1946 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1947 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1948 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1949
1950 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001951 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001952 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
1953 }
1954 peer->confirm++;
1955 }
1956 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
1957 struct shared_table *st;
1958
1959 /* If stopping state */
1960 if (stopping) {
1961 /* Close session, push resync no more needed */
1962 peer->flags |= PEER_F_TEACH_COMPLETE;
1963 appctx->st0 = PEER_SESS_ST_END;
1964 return 0;
1965 }
1966 for (st = peer->tables; st; st = st->next) {
1967 st->update = st->last_pushed = st->teaching_origin;
1968 st->flags = 0;
1969 }
1970
1971 /* reset teaching flags to 0 */
1972 peer->flags &= PEER_TEACH_RESET;
1973 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001974 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001975 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01001976 peer->rx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001977 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001978 }
1979 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
1980 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
1981 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
1982 return 0;
1983 }
1984 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
1985 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
1986 return 0;
1987 }
1988 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
1989 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
1990 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
1991 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
1992 int update, expire;
1993
1994 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
1995 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
1996 if (!peer_treat_updatemsg(appctx, peer, update, expire,
1997 msg_cur, msg_end, msg_len, totl))
1998 return 0;
1999
2000 }
2001 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
2002 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
2003 return 0;
2004 }
2005 }
2006 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
2007 appctx->st0 = PEER_SESS_ST_ERRPROTO;
2008 return 0;
2009 }
2010
2011 return 1;
2012}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002013
2014
2015/*
2016 * Send any message to <peer> peer.
2017 * Returns 1 if succeeded, or -1 or 0 if failed.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002018 * -1 means an internal error occurred, 0 is for a peer protocol error leading
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002019 * to a peer state change (from the peer I/O handler point of view).
2020 */
2021static inline int peer_send_msgs(struct appctx *appctx, struct peer *peer)
2022{
2023 int repl;
2024 struct stream_interface *si = appctx->owner;
2025 struct stream *s = si_strm(si);
2026 struct peers *peers = strm_fe(s)->parent;
2027
2028 /* Need to request a resync */
2029 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
2030 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2031 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
2032
2033 repl = peer_send_resync_reqmsg(appctx);
2034 if (repl <= 0)
2035 return repl;
2036
2037 peers->flags |= PEERS_F_RESYNC_PROCESS;
2038 }
2039
2040 /* Nothing to read, now we start to write */
2041 if (peer->tables) {
2042 struct shared_table *st;
2043 struct shared_table *last_local_table;
2044
2045 last_local_table = peer->last_local_table;
2046 if (!last_local_table)
2047 last_local_table = peer->tables;
2048 st = last_local_table->next;
2049
2050 while (1) {
2051 if (!st)
2052 st = peer->tables;
2053
2054 /* It remains some updates to ack */
2055 if (st->last_get != st->last_acked) {
2056 repl = peer_send_ackmsg(st, appctx);
2057 if (repl <= 0)
2058 return repl;
2059
2060 st->last_acked = st->last_get;
2061 }
2062
2063 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
2064 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
2065 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
2066 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
2067
2068 repl = peer_send_teach_process_msgs(appctx, peer, st);
2069 if (repl <= 0) {
2070 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
2071 return repl;
2072 }
2073 }
2074 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
2075 }
2076 else {
2077 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
2078 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
2079 if (repl <= 0)
2080 return repl;
2081 }
2082
2083 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
2084 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
2085 if (repl <= 0)
2086 return repl;
2087 }
2088 }
2089
2090 if (st == last_local_table)
2091 break;
2092 st = st->next;
2093 }
2094 }
2095
2096 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
Emeric Brun70de43b2020-03-16 10:51:01 +01002097 repl = peer_send_resync_finishedmsg(appctx, peers);
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002098 if (repl <= 0)
2099 return repl;
2100
2101 /* flag finished message sent */
2102 peer->flags |= PEER_F_TEACH_FINISHED;
2103 }
2104
2105 /* Confirm finished or partial messages */
2106 while (peer->confirm) {
2107 repl = peer_send_resync_confirmsg(appctx);
2108 if (repl <= 0)
2109 return repl;
2110
2111 peer->confirm--;
2112 }
2113
2114 return 1;
2115}
2116
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002117/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002118 * Read and parse a first line of a "hello" peer protocol message.
2119 * Returns 0 if could not read a line, -1 if there was a read error or
2120 * the line is malformed, 1 if succeeded.
2121 */
2122static inline int peer_getline_version(struct appctx *appctx,
2123 unsigned int *maj_ver, unsigned int *min_ver)
2124{
2125 int reql;
2126
2127 reql = peer_getline(appctx);
2128 if (!reql)
2129 return 0;
2130
2131 if (reql < 0)
2132 return -1;
2133
2134 /* test protocol */
2135 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
2136 appctx->st0 = PEER_SESS_ST_EXIT;
2137 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2138 return -1;
2139 }
2140 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
2141 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
2142 appctx->st0 = PEER_SESS_ST_EXIT;
2143 appctx->st1 = PEER_SESS_SC_ERRVERSION;
2144 return -1;
2145 }
2146
2147 return 1;
2148}
2149
2150/*
2151 * Read and parse a second line of a "hello" peer protocol message.
2152 * Returns 0 if could not read a line, -1 if there was a read error or
2153 * the line is malformed, 1 if succeeded.
2154 */
2155static inline int peer_getline_host(struct appctx *appctx)
2156{
2157 int reql;
2158
2159 reql = peer_getline(appctx);
2160 if (!reql)
2161 return 0;
2162
2163 if (reql < 0)
2164 return -1;
2165
2166 /* test hostname match */
2167 if (strcmp(localpeer, trash.area) != 0) {
2168 appctx->st0 = PEER_SESS_ST_EXIT;
2169 appctx->st1 = PEER_SESS_SC_ERRHOST;
2170 return -1;
2171 }
2172
2173 return 1;
2174}
2175
2176/*
2177 * Read and parse a last line of a "hello" peer protocol message.
2178 * Returns 0 if could not read a character, -1 if there was a read error or
2179 * the line is malformed, 1 if succeeded.
2180 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2181 */
2182static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2183{
2184 char *p;
2185 int reql;
2186 struct peer *peer;
2187 struct stream_interface *si = appctx->owner;
2188 struct stream *s = si_strm(si);
2189 struct peers *peers = strm_fe(s)->parent;
2190
2191 reql = peer_getline(appctx);
2192 if (!reql)
2193 return 0;
2194
2195 if (reql < 0)
2196 return -1;
2197
2198 /* parse line "<peer name> <pid> <relative_pid>" */
2199 p = strchr(trash.area, ' ');
2200 if (!p) {
2201 appctx->st0 = PEER_SESS_ST_EXIT;
2202 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2203 return -1;
2204 }
2205 *p = 0;
2206
2207 /* lookup known peer */
2208 for (peer = peers->remote; peer; peer = peer->next) {
2209 if (strcmp(peer->id, trash.area) == 0)
2210 break;
2211 }
2212
2213 /* if unknown peer */
2214 if (!peer) {
2215 appctx->st0 = PEER_SESS_ST_EXIT;
2216 appctx->st1 = PEER_SESS_SC_ERRPEER;
2217 return -1;
2218 }
2219 *curpeer = peer;
2220
2221 return 1;
2222}
2223
2224/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002225 * Init <peer> peer after having accepted it at peer protocol level.
2226 */
2227static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2228{
2229 struct shared_table *st;
2230
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002231 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002232 /* Register status code */
2233 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002234 peer->last_hdshk = now_ms;
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002235
2236 /* Awake main task */
2237 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2238
2239 /* Init confirm counter */
2240 peer->confirm = 0;
2241
2242 /* Init cursors */
2243 for (st = peer->tables; st ; st = st->next) {
2244 st->last_get = st->last_acked = 0;
2245 st->teaching_origin = st->last_pushed = st->update;
2246 }
2247
2248 /* reset teaching and learning flags to 0 */
2249 peer->flags &= PEER_TEACH_RESET;
2250 peer->flags &= PEER_LEARN_RESET;
2251
2252 /* if current peer is local */
2253 if (peer->local) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002254 /* if current host need resyncfrom local and no process assigned */
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002255 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2256 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2257 /* assign local peer for a lesson, consider lesson already requested */
2258 peer->flags |= PEER_F_LEARN_ASSIGN;
2259 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2260 }
2261
2262 }
2263 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2264 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2265 /* assign peer for a lesson */
2266 peer->flags |= PEER_F_LEARN_ASSIGN;
2267 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2268 }
2269}
2270
2271/*
2272 * Init <peer> peer after having connected it at peer protocol level.
2273 */
2274static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2275{
2276 struct shared_table *st;
2277
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002278 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002279 /* Init cursors */
2280 for (st = peer->tables; st ; st = st->next) {
2281 st->last_get = st->last_acked = 0;
2282 st->teaching_origin = st->last_pushed = st->update;
2283 }
2284
2285 /* Init confirm counter */
2286 peer->confirm = 0;
2287
2288 /* reset teaching and learning flags to 0 */
2289 peer->flags &= PEER_TEACH_RESET;
2290 peer->flags &= PEER_LEARN_RESET;
2291
2292 /* If current peer is local */
2293 if (peer->local) {
2294 /* flag to start to teach lesson */
2295 peer->flags |= PEER_F_TEACH_PROCESS;
2296 }
2297 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2298 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2299 /* If peer is remote and resync from remote is needed,
2300 and no peer currently assigned */
2301
2302 /* assign peer for a lesson */
2303 peer->flags |= PEER_F_LEARN_ASSIGN;
2304 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2305 }
2306}
2307
2308/*
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002309 * IO Handler to handle message exchange with a peer
Emeric Brun2b920a12010-09-23 18:30:22 +02002310 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002311static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002312{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002313 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002314 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002315 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002316 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002317 int reql = 0;
2318 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002319 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002320 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002321
Joseph Herlant82b2f542018-11-15 12:19:14 -08002322 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002323 if (si_ic(si)->buf.size == 0) {
2324 si_rx_room_blk(si);
2325 goto out;
2326 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002327
Emeric Brun2b920a12010-09-23 18:30:22 +02002328 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002329 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002330switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002331 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002332 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002333 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002334 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002335 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002336 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002337 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002338 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002339 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002340 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2341 if (reql <= 0) {
2342 if (!reql)
2343 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002344 goto switchstate;
2345 }
2346
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002347 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002348 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002349 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002350 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002351 reql = peer_getline_host(appctx);
2352 if (reql <= 0) {
2353 if (!reql)
2354 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002355 goto switchstate;
2356 }
2357
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002358 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002359 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002360 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002361 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002362 reql = peer_getline_last(appctx, &curpeer);
2363 if (reql <= 0) {
2364 if (!reql)
2365 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002366 goto switchstate;
2367 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002368
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002369 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002370 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002371 if (curpeer->local) {
2372 /* Local connection, reply a retry */
2373 appctx->st0 = PEER_SESS_ST_EXIT;
2374 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2375 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002376 }
Emeric Brun80527f52017-06-19 17:46:37 +02002377
2378 /* we're killing a connection, we must apply a random delay before
2379 * retrying otherwise the other end will do the same and we can loop
2380 * for a while.
2381 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002382 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002383 peer_session_forceshutdown(curpeer);
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002384 curpeer->heartbeat = TICK_ETERNITY;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002385 curpeer->coll++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002386 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002387 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2388 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2389 curpeer->flags |= PEER_F_DWNGRD;
2390 }
2391 else {
2392 curpeer->flags &= ~PEER_F_DWNGRD;
2393 }
2394 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002395 curpeer->appctx = appctx;
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002396 curpeer->flags |= PEER_F_ALIVE;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002397 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002398 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002399 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002400 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002401 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002402 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002403 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002404 if (!curpeer) {
2405 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002406 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002407 if (curpeer->appctx != appctx) {
2408 appctx->st0 = PEER_SESS_ST_END;
2409 goto switchstate;
2410 }
2411 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002412
2413 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002414 if (repl <= 0) {
2415 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002416 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002417 goto switchstate;
2418 }
2419
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002420 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002421
Emeric Brun2b920a12010-09-23 18:30:22 +02002422 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002423 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002424 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002425 goto switchstate;
2426 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002427 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002428 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002429 if (!curpeer) {
2430 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002431 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002432 if (curpeer->appctx != appctx) {
2433 appctx->st0 = PEER_SESS_ST_END;
2434 goto switchstate;
2435 }
2436 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002437
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002438 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002439 if (repl <= 0) {
2440 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002441 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002442 goto switchstate;
2443 }
2444
2445 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002446 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002447 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002448 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002449 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002450 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002451 if (!curpeer) {
2452 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002453 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002454 if (curpeer->appctx != appctx) {
2455 appctx->st0 = PEER_SESS_ST_END;
2456 goto switchstate;
2457 }
2458 }
2459
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002460 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002461 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002462
Frédéric Lécaillece025572019-01-21 13:38:06 +01002463 reql = peer_getline(appctx);
2464 if (!reql)
2465 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002466
Frédéric Lécaillece025572019-01-21 13:38:06 +01002467 if (reql < 0)
2468 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002469
2470 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002471 curpeer->statuscode = atoi(trash.area);
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002472 curpeer->last_hdshk = now_ms;
Emeric Brun2b920a12010-09-23 18:30:22 +02002473
2474 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002475 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002476
2477 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002478 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002479 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002480 }
2481 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002482 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2483 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002484 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002485 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002486 goto switchstate;
2487 }
Olivier Houcharded879892019-03-08 18:53:43 +01002488 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002489 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002490 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002491 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002492 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002493 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002494 char *msg_cur = trash.area;
2495 char *msg_end = trash.area;
Willy Tarreau1dfd4f12020-11-13 14:10:20 +01002496 unsigned char msg_head[7]; // 2 + 5 for varint32
Emeric Brun2b920a12010-09-23 18:30:22 +02002497 int totl = 0;
2498
Willy Tarreau2d372c22018-11-05 17:12:27 +01002499 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002500 if (!curpeer) {
2501 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002502 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002503 if (curpeer->appctx != appctx) {
2504 appctx->st0 = PEER_SESS_ST_END;
2505 goto switchstate;
2506 }
2507 }
2508
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002509 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2510 if (reql <= 0) {
2511 if (reql == -1)
2512 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002513 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002514 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002515
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002516 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002517 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002518 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002519
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002520 curpeer->flags |= PEER_F_ALIVE;
2521
Emeric Brun2b920a12010-09-23 18:30:22 +02002522 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002523 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002524 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002525 goto switchstate;
2526
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002527send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002528 if (curpeer->flags & PEER_F_HEARTBEAT) {
2529 curpeer->flags &= ~PEER_F_HEARTBEAT;
2530 repl = peer_send_heartbeatmsg(appctx);
2531 if (repl <= 0) {
2532 if (repl == -1)
2533 goto out;
2534 goto switchstate;
2535 }
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002536 curpeer->tx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002537 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002538 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002539 repl = peer_send_msgs(appctx, curpeer);
2540 if (repl <= 0) {
2541 if (repl == -1)
2542 goto out;
2543 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002544 }
2545
Emeric Brun2b920a12010-09-23 18:30:22 +02002546 /* noting more to do */
2547 goto out;
2548 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002549 case PEER_SESS_ST_EXIT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002550 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002551 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002552 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002553 if (peer_send_status_errormsg(appctx) == -1)
2554 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002555 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002556 goto switchstate;
2557 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002558 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002559 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002560 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002561 if (peer_send_error_size_limitmsg(appctx) == -1)
2562 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002563 appctx->st0 = PEER_SESS_ST_END;
2564 goto switchstate;
2565 }
2566 case PEER_SESS_ST_ERRPROTO: {
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002567 if (curpeer)
2568 curpeer->proto_err++;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002569 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002570 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002571 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002572 if (peer_send_error_protomsg(appctx) == -1)
2573 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002574 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002575 prev_state = appctx->st0;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002576 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02002577 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002578 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002579 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002580 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002581 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002582 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002583 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002584 curpeer = NULL;
2585 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002586 si_shutw(si);
2587 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002588 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002589 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002590 }
2591 }
2592 }
2593out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002594 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002595
2596 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002597 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002598 return;
2599}
2600
Willy Tarreau30576452015-04-13 13:50:30 +02002601static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002602 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002603 .name = "<PEER>", /* used for logging */
2604 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002605 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002606};
Emeric Brun2b920a12010-09-23 18:30:22 +02002607
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002608
Emeric Brun2b920a12010-09-23 18:30:22 +02002609/*
2610 * Use this function to force a close of a peer session
2611 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002612static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002613{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002614 struct appctx *appctx = peer->appctx;
2615
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002616 /* Note that the peer sessions which have just been created
2617 * (->st0 == PEER_SESS_ST_CONNECT) must not
2618 * be shutdown, if not, the TCP session will never be closed
2619 * and stay in CLOSE_WAIT state after having been closed by
2620 * the remote side.
2621 */
2622 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002623 return;
2624
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002625 if (appctx->applet != &peer_applet)
2626 return;
2627
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002628 __peer_session_deinit(peer);
2629
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002630 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002631 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002632}
2633
Willy Tarreau91d96282015-03-13 15:47:26 +01002634/* Pre-configures a peers frontend to accept incoming connections */
2635void peers_setup_frontend(struct proxy *fe)
2636{
2637 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002638 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002639 fe->mode = PR_MODE_PEERS;
Willy Tarreau91d96282015-03-13 15:47:26 +01002640 fe->maxconn = 0;
2641 fe->conn_retries = CONN_RETRIES;
2642 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002643 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002644 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002645 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002646 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002647}
2648
Emeric Brun2b920a12010-09-23 18:30:22 +02002649/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002650 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002651 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002652static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002653{
Willy Tarreau04b92862017-09-15 11:01:04 +02002654 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002655 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002656 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002657 struct stream *s;
Emeric Brun2b920a12010-09-23 18:30:22 +02002658
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002659 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002660 peer->heartbeat = TICK_ETERNITY;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002661 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02002662 peer->last_hdshk = now_ms;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002663 s = NULL;
2664
Emeric Brun1138fd02017-06-19 12:38:55 +02002665 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002666 if (!appctx)
2667 goto out_close;
2668
2669 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002670 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002671
Willy Tarreau04b92862017-09-15 11:01:04 +02002672 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002673 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002674 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002675 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002676 }
2677
Willy Tarreau87787ac2017-08-28 16:22:54 +02002678 if ((s = stream_new(sess, &appctx->obj_type)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002679 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002680 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002681 }
2682
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002683 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002684 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002685 appctx_wakeup(appctx);
2686
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002687 /* initiate an outgoing connection */
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002688 s->target = peer_session_target(peer, s);
Willy Tarreau9b7587a2020-10-15 07:32:10 +02002689 if (!sockaddr_alloc(&s->target_addr, &peer->addr, sizeof(peer->addr)))
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002690 goto out_free_strm;
Willy Tarreau02efeda2019-07-18 17:21:24 +02002691 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Willy Tarreaudbd02672017-12-06 17:39:53 +01002692 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002693
Emeric Brun2b920a12010-09-23 18:30:22 +02002694 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002695 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002696
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002697 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002698
Emeric Brunb3971ab2015-05-12 18:49:09 +02002699 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002700 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002701 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002702 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002703
2704 /* Error unrolling */
Willy Tarreau15b5e142015-04-04 14:38:25 +02002705 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002706 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002707 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002708 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002709 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002710 out_free_appctx:
2711 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002712 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002713 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002714}
2715
2716/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002717 * Task processing function to manage re-connect, peer session
2718 * tasks wakeup on local update and heartbeat.
Emeric Brun2b920a12010-09-23 18:30:22 +02002719 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02002720static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002721{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002722 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002723 struct peer *ps;
2724 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002725
2726 task->expire = TICK_ETERNITY;
2727
Emeric Brunb3971ab2015-05-12 18:49:09 +02002728 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002729 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002730 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002731 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002732 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002733 return NULL;
2734 }
2735
Emeric Brun80527f52017-06-19 17:46:37 +02002736 /* Acquire lock for all peers of the section */
2737 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002738 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002739
Emeric Brun2b920a12010-09-23 18:30:22 +02002740 if (!stopping) {
2741 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002742
2743 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2744 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2745 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002746 /* Resync from local peer needed
2747 no peer was assigned for the lesson
2748 and no old local peer found
2749 or resync timeout expire */
2750
2751 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002752 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002753
2754 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002755 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002756 }
2757
2758 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002759 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002760 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002761 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002762 if (!ps->appctx) {
2763 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002764 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002765 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002766 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002767 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002768 tick_is_expired(ps->reconnect, now_ms))) {
2769 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002770 * or previous peer connection established with success
2771 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002772 * and reconnection timer is expired */
2773
2774 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002775 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002776 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002777 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002778 /* If previous session failed during connection
2779 * but reconnection timer is not expired */
2780
2781 /* reschedule task for reconnect */
2782 task->expire = tick_first(task->expire, ps->reconnect);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002783 ps->new_conn++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002784 }
2785 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002786 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002787 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002788 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002789 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2790 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002791 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2792 /* Resync from a remote is needed
2793 * and no peer was assigned for lesson
2794 * and current peer may be up2date */
2795
2796 /* assign peer for the lesson */
2797 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002798 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002799
Willy Tarreau9df94c22016-10-31 18:42:52 +01002800 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002801 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002802 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002803 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002804 int update_to_push = 0;
2805
Emeric Brunb3971ab2015-05-12 18:49:09 +02002806 /* Awake session if there is data to push */
2807 for (st = ps->tables; st ; st = st->next) {
2808 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002809 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002810 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002811 /* There is no need to send a heartbeat message
2812 * when some updates must be pushed. The remote
2813 * peer will consider <ps> peer as alive when it will
2814 * receive these updates.
2815 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002816 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002817 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002818 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002819 /* We are going to send updates, let's ensure we will
2820 * come back to send heartbeat messages or to reconnect.
2821 */
2822 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002823 appctx_wakeup(ps->appctx);
2824 break;
2825 }
2826 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002827 /* When there are updates to send we do not reconnect
2828 * and do not send heartbeat message either.
2829 */
2830 if (!update_to_push) {
2831 if (tick_is_expired(ps->reconnect, now_ms)) {
2832 if (ps->flags & PEER_F_ALIVE) {
2833 /* This peer was alive during a 'reconnect' period.
2834 * Flag it as not alive again for the next period.
2835 */
2836 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002837 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002838 }
2839 else {
Willy Tarreau52bf8392020-03-08 00:42:37 +01002840 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Frédéric Lécaillebaeb9192020-10-14 11:50:26 +02002841 ps->heartbeat = TICK_ETERNITY;
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002842 peer_session_forceshutdown(ps);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002843 ps->no_hbt++;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002844 }
2845 }
2846 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2847 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
2848 ps->flags |= PEER_F_HEARTBEAT;
2849 appctx_wakeup(ps->appctx);
2850 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01002851 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002852 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002853 }
2854 /* else do nothing */
2855 } /* SUCCESSCODE */
2856 } /* !ps->peer->local */
2857 } /* for */
2858
2859 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002860 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2861 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2862 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002863 /* Resync from remote peer needed
2864 * no peer was assigned for the lesson
2865 * and resync timeout expire */
2866
2867 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002868 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002869 }
2870
Emeric Brunb3971ab2015-05-12 18:49:09 +02002871 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002872 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02002873 /* reschedule task to resync timeout if not expired, to ended resync if needed */
2874 if (!tick_is_expired(peers->resync_timeout, now_ms))
2875 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02002876 }
2877 } /* !stopping */
2878 else {
2879 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01002880 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08002881 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002882 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002883 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01002884 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002885 peers->flags |= PEERS_F_DONOTSTOP;
2886 ps = peers->local;
2887 for (st = ps->tables; st ; st = st->next)
2888 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002889 }
2890
2891 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002892 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02002893 /* we're killing a connection, we must apply a random delay before
2894 * retrying otherwise the other end will do the same and we can loop
2895 * for a while.
2896 */
Willy Tarreau52bf8392020-03-08 00:42:37 +01002897 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + ha_random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01002898 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002899 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002900 }
2901 }
2902 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002903
Emeric Brunb3971ab2015-05-12 18:49:09 +02002904 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02002905 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002906 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002907 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002908 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002909 peers->flags &= ~PEERS_F_DONOTSTOP;
2910 for (st = ps->tables; st ; st = st->next)
2911 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002912 }
2913 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01002914 else if (!ps->appctx) {
2915 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002916 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002917 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
2918 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
2919 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002920 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002921 * or previous peer connection was successfully established
2922 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02002923 * or during previous connect, peer replies a try again statuscode */
2924
2925 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002926 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002927 }
2928 else {
2929 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002930 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002931 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002932 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002933 peers->flags &= ~PEERS_F_DONOTSTOP;
2934 for (st = ps->tables; st ; st = st->next)
2935 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002936 }
2937 }
2938 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002939 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002940 /* current peer connection is active and established
2941 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002942 for (st = ps->tables; st ; st = st->next) {
2943 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002944 appctx_wakeup(ps->appctx);
2945 break;
2946 }
2947 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002948 }
2949 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02002950
2951 /* Release lock for all peers of the section */
2952 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002953 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002954
Emeric Brun2b920a12010-09-23 18:30:22 +02002955 /* Wakeup for re-connect */
2956 return task;
2957}
2958
Emeric Brunb3971ab2015-05-12 18:49:09 +02002959
Emeric Brun2b920a12010-09-23 18:30:22 +02002960/*
Willy Tarreaud9443442018-10-15 11:18:03 +02002961 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02002962 */
Willy Tarreaud9443442018-10-15 11:18:03 +02002963int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02002964{
Emeric Brun2b920a12010-09-23 18:30:22 +02002965 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02002966
Emeric Brun2b920a12010-09-23 18:30:22 +02002967 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002968 peers->peers_fe->maxconn += 3;
2969 }
2970
Emeric Brunc60def82017-09-27 14:59:38 +02002971 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02002972 if (!peers->sync_task)
2973 return 0;
2974
Emeric Brunb3971ab2015-05-12 18:49:09 +02002975 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002976 peers->sync_task->context = (void *)peers;
2977 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
2978 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02002979 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002980}
2981
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002982/*
2983 * Allocate a cache a dictionary entries used upon transmission.
2984 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002985static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002986{
2987 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002988 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002989
2990 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002991 entries = calloc(max_entries, sizeof *entries);
2992 if (!d || !entries)
2993 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002994
2995 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002996 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002997 d->cached_entries = EB_ROOT_UNIQUE;
2998 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002999
3000 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003001
3002 err:
3003 free(d);
3004 free(entries);
3005 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003006}
3007
3008/*
3009 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
3010 * as maximum of entries.
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05003011 * Return the dictionary cache if succeeded, NULL if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003012 * Must be deallocated calling free_dcache().
3013 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003014static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003015{
3016 struct dcache_tx *dc_tx;
3017 struct dcache *dc;
3018 struct dcache_rx *dc_rx;
3019
3020 dc = calloc(1, sizeof *dc);
3021 dc_tx = new_dcache_tx(max_entries);
3022 dc_rx = calloc(max_entries, sizeof *dc_rx);
3023 if (!dc || !dc_tx || !dc_rx)
3024 goto err;
3025
3026 dc->tx = dc_tx;
3027 dc->rx = dc_rx;
3028 dc->max_entries = max_entries;
3029
3030 return dc;
3031
3032 err:
3033 free(dc);
3034 free(dc_tx);
3035 free(dc_rx);
3036 return NULL;
3037}
3038
3039/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003040 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
3041 * entries used upon transmission.
3042 * Return the entry if found, NULL if not.
3043 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003044static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
3045 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003046{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003047 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003048}
3049
3050/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003051 * Flush <dc> cache.
3052 * Always succeeds.
3053 */
3054static inline void flush_dcache(struct peer *peer)
3055{
3056 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003057 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003058
Frédéric Lécailleea875e62020-11-12 21:01:54 +01003059 for (i = 0; i < dc->max_entries; i++) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003060 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécailleea875e62020-11-12 21:01:54 +01003061 dc->tx->entries[i].key = NULL;
3062 }
3063 dc->tx->prev_lookup = NULL;
3064 dc->tx->lru_key = 0;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003065
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003066 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003067}
3068
3069/*
3070 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
3071 * with information provided by <i> dictionary cache entry (especially the value
3072 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003073 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003074 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003075static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003076{
3077 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003078 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003079
3080 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02003081
3082 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
3083 o = dc_tx->prev_lookup;
3084 } else {
3085 o = dcache_tx_lookup_value(dc_tx, i);
3086 if (o) {
3087 /* Save it */
3088 dc_tx->prev_lookup = o;
3089 }
3090 }
3091
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003092 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003093 /* Copy the ID. */
3094 i->id = o - dc->tx->entries;
3095 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003096 }
3097
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003098 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02003099 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003100
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003101 ebpt_delete(o);
3102 o->key = i->entry.key;
3103 ebpt_insert(&dc_tx->cached_entries, o);
3104 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003105
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003106 /* Update the index for the next entry to put in cache */
3107 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02003108
Frédéric Lécaille74167b22019-05-28 19:02:42 +02003109 return o;
3110}
Emeric Brunb3971ab2015-05-12 18:49:09 +02003111
3112/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003113 * Allocate a dictionary cache for each peer of <peers> section.
3114 * Return 1 if succeeded, 0 if not.
3115 */
3116int peers_alloc_dcache(struct peers *peers)
3117{
3118 struct peer *p;
3119
3120 for (p = peers->remote; p; p = p->next) {
3121 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
3122 if (!p->dcache)
3123 return 0;
3124 }
3125
3126 return 1;
3127}
3128
3129/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02003130 * Function used to register a table for sync on a group of peers
3131 *
3132 */
3133void peers_register_table(struct peers *peers, struct stktable *table)
3134{
3135 struct shared_table *st;
3136 struct peer * curpeer;
3137 int id = 0;
3138
3139 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003140 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003141 st->table = table;
3142 st->next = curpeer->tables;
3143 if (curpeer->tables)
3144 id = curpeer->tables->local_id;
3145 st->local_id = id + 1;
3146
3147 curpeer->tables = st;
3148 }
3149
3150 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003151}
3152
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003153/*
3154 * Parse the "show peers" command arguments.
3155 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3156 * error message.
3157 */
3158static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3159{
3160 appctx->ctx.cfgpeers.target = NULL;
3161
3162 if (*args[2]) {
3163 struct peers *p;
3164
3165 for (p = cfg_peers; p; p = p->next) {
3166 if (!strcmp(p->id, args[2])) {
3167 appctx->ctx.cfgpeers.target = p;
3168 break;
3169 }
3170 }
3171
Willy Tarreau9d008692019-08-09 11:21:01 +02003172 if (!p)
3173 return cli_err(appctx, "No such peers\n");
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003174 }
3175
3176 return 0;
3177}
3178
3179/*
3180 * This function dumps the peer state information of <peers> "peers" section.
3181 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3182 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3183 */
3184static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3185{
3186 struct tm tm;
3187
3188 get_localtime(peers->last_change, &tm);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003189 chunk_appendf(msg, "%p: [%02d/%s/%04d:%02d:%02d:%02d] id=%s disabled=%d flags=0x%x resync_timeout=%s task_calls=%u\n",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003190 peers,
3191 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3192 tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003193 peers->id, peers->disabled, peers->flags,
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003194 peers->resync_timeout ?
3195 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3196 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003197 TICKS_TO_MS(1000)) : "<NEVER>",
3198 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003199
3200 if (ci_putchk(si_ic(si), msg) == -1) {
3201 si_rx_room_blk(si);
3202 return 0;
3203 }
3204
3205 return 1;
3206}
3207
3208/*
3209 * This function dumps <peer> state information.
3210 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3211 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3212 */
3213static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3214{
3215 struct connection *conn;
3216 char pn[INET6_ADDRSTRLEN];
3217 struct stream_interface *peer_si;
3218 struct stream *peer_s;
3219 struct appctx *appctx;
3220 struct shared_table *st;
3221
3222 addr_to_str(&peer->addr, pn, sizeof pn);
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003223 chunk_appendf(msg, " %p: id=%s(%s,%s) addr=%s:%d last_status=%s",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003224 peer, peer->id,
3225 peer->local ? "local" : "remote",
Frédéric Lécaillee7e2b212020-10-05 12:33:07 +02003226 peer->appctx ? "active" : "inactive",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003227 pn, get_host_port(&peer->addr),
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003228 statuscode_str(peer->statuscode));
3229
3230 chunk_appendf(msg, " last_hdshk=%s\n",
3231 peer->last_hdshk ? human_time(TICKS_TO_MS(now_ms - peer->last_hdshk),
3232 TICKS_TO_MS(1000)) : "<NEVER>");
3233
3234 chunk_appendf(msg, " reconnect=%s",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003235 peer->reconnect ?
3236 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3237 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003238 TICKS_TO_MS(1000)) : "<NEVER>");
3239
3240 chunk_appendf(msg, " heartbeat=%s",
3241 peer->heartbeat ?
3242 tick_is_expired(peer->heartbeat, now_ms) ? "<PAST>" :
3243 human_time(TICKS_TO_MS(peer->heartbeat - now_ms),
3244 TICKS_TO_MS(1000)) : "<NEVER>");
3245
3246 chunk_appendf(msg, " confirm=%u tx_hbt=%u rx_hbt=%u no_hbt=%u new_conn=%u proto_err=%u coll=%u\n",
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003247 peer->confirm, peer->tx_hbt, peer->rx_hbt,
Frédéric Lécaille3fc0fe02020-10-08 09:46:24 +02003248 peer->no_hbt, peer->new_conn, peer->proto_err, peer->coll);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003249
3250 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3251
3252 appctx = peer->appctx;
3253 if (!appctx)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003254 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003255
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003256 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3257 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003258
3259 peer_si = peer->appctx->owner;
3260 if (!peer_si)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003261 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003262
3263 peer_s = si_strm(peer_si);
3264 if (!peer_s)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003265 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003266
3267 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3268
3269 conn = objt_conn(strm_orig(peer_s));
3270 if (conn)
3271 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3272
Willy Tarreau3ca14902019-07-17 14:53:15 +02003273 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 +02003274 case AF_INET:
3275 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003276 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(conn->src));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003277 break;
3278 case AF_UNIX:
3279 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3280 break;
3281 }
3282
Willy Tarreau3ca14902019-07-17 14:53:15 +02003283 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 +02003284 case AF_INET:
3285 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003286 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(conn->dst));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003287 break;
3288 case AF_UNIX:
3289 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3290 break;
3291 }
3292
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003293 table_info:
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003294 if (peer->remote_table)
3295 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3296 peer->remote_table,
3297 peer->remote_table->table->id,
3298 peer->remote_table->local_id,
3299 peer->remote_table->remote_id);
3300
3301 if (peer->last_local_table)
3302 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3303 peer->last_local_table,
3304 peer->last_local_table->table->id,
3305 peer->last_local_table->local_id,
3306 peer->last_local_table->remote_id);
3307
3308 if (peer->tables) {
3309 chunk_appendf(&trash, "\n shared tables:");
3310 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003311 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003312 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003313 struct dcache *dcache;
3314
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003315 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003316 dcache = peer->dcache;
3317
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003318 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3319 "flags=0x%x remote_data=0x%llx",
3320 st, st->local_id, st->remote_id,
3321 st->flags, (unsigned long long)st->remote_data);
3322 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3323 " teaching_origin=%u update=%u",
3324 st->last_acked, st->last_pushed, st->last_get,
3325 st->teaching_origin, st->update);
3326 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3327 " commitupdate=%u syncing=%u",
3328 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003329 chunk_appendf(&trash, "\n TX dictionary cache:");
3330 count = 0;
3331 for (i = 0; i < dcache->max_entries; i++) {
3332 struct ebpt_node *node;
3333 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003334
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003335 node = &dcache->tx->entries[i];
3336 if (!node->key)
3337 break;
3338
3339 if (!count++)
3340 chunk_appendf(&trash, "\n ");
3341 de = node->key;
3342 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3343 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003344 }
3345 chunk_appendf(&trash, "\n RX dictionary cache:");
3346 count = 0;
3347 for (i = 0; i < dcache->max_entries; i++) {
3348 if (!count++)
3349 chunk_appendf(&trash, "\n ");
3350 chunk_appendf(&trash, " %3u -> %s", i,
3351 dcache->rx[i].de ?
3352 (char *)dcache->rx[i].de->value.key : "-");
3353 count &= 0x3;
3354 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003355 }
3356 }
3357
3358 end:
3359 chunk_appendf(&trash, "\n");
3360 if (ci_putchk(si_ic(si), msg) == -1) {
3361 si_rx_room_blk(si);
3362 return 0;
3363 }
3364
3365 return 1;
3366}
3367
3368/*
3369 * This function dumps all the peers of "peers" section.
3370 * Returns 0 if the output buffer is full and needs to be called
3371 * again, non-zero if not. It proceeds in an isolated thread, so
3372 * there is no thread safety issue here.
3373 */
3374static int cli_io_handler_show_peers(struct appctx *appctx)
3375{
3376 int show_all;
3377 int ret = 0, first_peers = 1;
3378 struct stream_interface *si = appctx->owner;
3379
3380 thread_isolate();
3381
3382 show_all = !appctx->ctx.cfgpeers.target;
3383
3384 chunk_reset(&trash);
3385
3386 while (appctx->st2 != STAT_ST_FIN) {
3387 switch (appctx->st2) {
3388 case STAT_ST_INIT:
3389 if (show_all)
3390 appctx->ctx.cfgpeers.peers = cfg_peers;
3391 else
3392 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3393
3394 appctx->st2 = STAT_ST_LIST;
3395 /* fall through */
3396
3397 case STAT_ST_LIST:
3398 if (!appctx->ctx.cfgpeers.peers) {
3399 /* No more peers list. */
3400 appctx->st2 = STAT_ST_END;
3401 }
3402 else {
3403 if (!first_peers)
3404 chunk_appendf(&trash, "\n");
3405 else
3406 first_peers = 0;
3407 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3408 goto out;
3409
3410 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3411 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3412 appctx->st2 = STAT_ST_INFO;
3413 }
3414 break;
3415
3416 case STAT_ST_INFO:
3417 if (!appctx->ctx.cfgpeers.peer) {
3418 /* End of peer list */
3419 if (show_all)
3420 appctx->st2 = STAT_ST_LIST;
3421 else
3422 appctx->st2 = STAT_ST_END;
3423 }
3424 else {
3425 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3426 goto out;
3427
3428 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3429 }
3430 break;
3431
3432 case STAT_ST_END:
3433 appctx->st2 = STAT_ST_FIN;
3434 break;
3435 }
3436 }
3437 ret = 1;
3438 out:
3439 thread_release();
3440 return ret;
3441}
3442
3443/*
3444 * CLI keywords.
3445 */
3446static struct cli_kw_list cli_kws = {{ }, {
3447 { { "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, },
3448 {},
3449}};
3450
3451/* Register cli keywords */
3452INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3453