blob: e2581a73b9510106bb3079d5691f0d4368599abf [file] [log] [blame]
Emeric Brun2b920a12010-09-23 18:30:22 +02001/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02002 * Peer synchro management.
Emeric Brun2b920a12010-09-23 18:30:22 +02003 *
4 * Copyright 2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <errno.h>
14#include <fcntl.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18
19#include <sys/socket.h>
20#include <sys/stat.h>
21#include <sys/types.h>
22
23#include <common/compat.h>
24#include <common/config.h>
25#include <common/time.h>
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +020026#include <common/standard.h>
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +020027#include <common/hathreads.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020028
29#include <types/global.h>
Willy Tarreau3fdb3662012-11-12 00:42:33 +010030#include <types/listener.h>
31#include <types/obj_type.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020032#include <types/peers.h>
Frédéric Lécaille95679dc2019-04-15 10:25:27 +020033#include <types/stats.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020034
35#include <proto/acl.h>
Willy Tarreau8a8d83b2015-04-13 13:24:54 +020036#include <proto/applet.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020037#include <proto/channel.h>
Frédéric Lécaille95679dc2019-04-15 10:25:27 +020038#include <proto/cli.h>
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +020039#include <proto/dict.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020040#include <proto/fd.h>
Willy Tarreaud1d48d42015-03-13 16:15:46 +010041#include <proto/frontend.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020042#include <proto/log.h>
Willy Tarreau53a47662017-08-28 10:53:00 +020043#include <proto/mux_pt.h>
Frédéric Lécaille1055e682018-04-26 14:35:21 +020044#include <proto/peers.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020045#include <proto/proxy.h>
Willy Tarreaufeb76402015-04-03 14:10:06 +020046#include <proto/session.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020047#include <proto/stream.h>
Willy Tarreau22ec1ea2014-11-27 20:45:39 +010048#include <proto/signal.h>
49#include <proto/stick_table.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020050#include <proto/stream_interface.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020051#include <proto/task.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020052
53
54/*******************************/
55/* Current peer learning state */
56/*******************************/
57
58/******************************/
Emeric Brunb3971ab2015-05-12 18:49:09 +020059/* Current peers section resync state */
Emeric Brun2b920a12010-09-23 18:30:22 +020060/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010061#define PEERS_F_RESYNC_LOCAL 0x00000001 /* Learn from local finished or no more needed */
62#define PEERS_F_RESYNC_REMOTE 0x00000002 /* Learn from remote finished or no more needed */
63#define PEERS_F_RESYNC_ASSIGN 0x00000004 /* A peer was assigned to learn our lesson */
64#define PEERS_F_RESYNC_PROCESS 0x00000008 /* The assigned peer was requested for resync */
65#define PEERS_F_DONOTSTOP 0x00010000 /* Main table sync task block process during soft stop
66 to push data to new process */
Emeric Brun2b920a12010-09-23 18:30:22 +020067
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010068#define PEERS_RESYNC_STATEMASK (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
69#define PEERS_RESYNC_FROMLOCAL 0x00000000
70#define PEERS_RESYNC_FROMREMOTE PEERS_F_RESYNC_LOCAL
71#define PEERS_RESYNC_FINISHED (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
Emeric Brunb3971ab2015-05-12 18:49:09 +020072
73/***********************************/
74/* Current shared table sync state */
75/***********************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010076#define SHTABLE_F_TEACH_STAGE1 0x00000001 /* Teach state 1 complete */
77#define SHTABLE_F_TEACH_STAGE2 0x00000002 /* Teach state 2 complete */
Emeric Brun2b920a12010-09-23 18:30:22 +020078
79/******************************/
80/* Remote peer teaching state */
81/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010082#define PEER_F_TEACH_PROCESS 0x00000001 /* Teach a lesson to current peer */
83#define PEER_F_TEACH_FINISHED 0x00000008 /* Teach conclude, (wait for confirm) */
84#define PEER_F_TEACH_COMPLETE 0x00000010 /* All that we know already taught to current peer, used only for a local peer */
85#define PEER_F_LEARN_ASSIGN 0x00000100 /* Current peer was assigned for a lesson */
86#define PEER_F_LEARN_NOTUP2DATE 0x00000200 /* Learn from peer finished but peer is not up to date */
87#define PEER_F_ALIVE 0x20000000 /* Used to flag a peer a alive. */
88#define PEER_F_HEARTBEAT 0x40000000 /* Heartbeat message to send. */
89#define PEER_F_DWNGRD 0x80000000 /* When this flag is enabled, we must downgrade the supported version announced during peer sessions. */
Emeric Brun2b920a12010-09-23 18:30:22 +020090
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010091#define PEER_TEACH_RESET ~(PEER_F_TEACH_PROCESS|PEER_F_TEACH_FINISHED) /* PEER_F_TEACH_COMPLETE should never be reset */
92#define PEER_LEARN_RESET ~(PEER_F_LEARN_ASSIGN|PEER_F_LEARN_NOTUP2DATE)
Emeric Brun2b920a12010-09-23 18:30:22 +020093
Frédéric Lécaille54bff832019-03-26 10:25:20 +010094#define PEER_RESYNC_TIMEOUT 5000 /* 5 seconds */
95#define PEER_RECONNECT_TIMEOUT 5000 /* 5 seconds */
Frédéric Lécaille645635d2019-02-11 17:49:39 +010096#define PEER_HEARTBEAT_TIMEOUT 3000 /* 3 seconds */
97
Emeric Brunb3971ab2015-05-12 18:49:09 +020098/*****************************/
99/* Sync message class */
100/*****************************/
101enum {
102 PEER_MSG_CLASS_CONTROL = 0,
103 PEER_MSG_CLASS_ERROR,
104 PEER_MSG_CLASS_STICKTABLE = 10,
105 PEER_MSG_CLASS_RESERVED = 255,
106};
107
108/*****************************/
109/* control message types */
110/*****************************/
111enum {
112 PEER_MSG_CTRL_RESYNCREQ = 0,
113 PEER_MSG_CTRL_RESYNCFINISHED,
114 PEER_MSG_CTRL_RESYNCPARTIAL,
115 PEER_MSG_CTRL_RESYNCCONFIRM,
Frédéric Lécaille645635d2019-02-11 17:49:39 +0100116 PEER_MSG_CTRL_HEARTBEAT,
Emeric Brunb3971ab2015-05-12 18:49:09 +0200117};
118
119/*****************************/
120/* error message types */
121/*****************************/
122enum {
123 PEER_MSG_ERR_PROTOCOL = 0,
124 PEER_MSG_ERR_SIZELIMIT,
125};
126
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100127/*
128 * Parameters used by functions to build peer protocol messages. */
129struct peer_prep_params {
130 struct {
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100131 struct peer *peer;
132 } hello;
133 struct {
134 unsigned int st1;
135 } error_status;
136 struct {
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100137 struct stksess *stksess;
138 struct shared_table *shared_table;
139 unsigned int updateid;
140 int use_identifier;
141 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200142 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100143 } updt;
144 struct {
145 struct shared_table *shared_table;
146 } swtch;
147 struct {
148 struct shared_table *shared_table;
149 } ack;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100150 struct {
151 unsigned char head[2];
152 } control;
153 struct {
154 unsigned char head[2];
155 } error;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100156};
Emeric Brunb3971ab2015-05-12 18:49:09 +0200157
158/*******************************/
159/* stick table sync mesg types */
160/* Note: ids >= 128 contains */
161/* id message cotains data */
162/*******************************/
Olivier Houchard33992262018-10-16 18:49:26 +0200163#define PEER_MSG_STKT_UPDATE 0x80
164#define PEER_MSG_STKT_INCUPDATE 0x81
165#define PEER_MSG_STKT_DEFINE 0x82
166#define PEER_MSG_STKT_SWITCH 0x83
167#define PEER_MSG_STKT_ACK 0x84
168#define PEER_MSG_STKT_UPDATE_TIMED 0x85
169#define PEER_MSG_STKT_INCUPDATE_TIMED 0x86
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +0200170/* All the stick-table message identifiers abova have the #7 bit set */
171#define PEER_MSG_STKT_BIT 7
172#define PEER_MSG_STKT_BIT_MASK (1 << PEER_MSG_STKT_BIT)
Emeric Brun2b920a12010-09-23 18:30:22 +0200173
Frédéric Lécaille39143342019-05-24 14:32:27 +0200174/* The maximum length of an encoded data length. */
175#define PEER_MSG_ENC_LENGTH_MAXLEN 5
176
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200177/* Minimum 64-bits value encoded with 2 bytes */
178#define PEER_ENC_2BYTES_MIN 0xf0 /* 0xf0 (or 240) */
179/* 3 bytes */
180#define PEER_ENC_3BYTES_MIN ((1ULL << 11) | PEER_ENC_2BYTES_MIN) /* 0x8f0 (or 2288) */
181/* 4 bytes */
182#define PEER_ENC_4BYTES_MIN ((1ULL << 18) | PEER_ENC_3BYTES_MIN) /* 0x408f0 (or 264432) */
183/* 5 bytes */
184#define PEER_ENC_5BYTES_MIN ((1ULL << 25) | PEER_ENC_4BYTES_MIN) /* 0x20408f0 (or 33818864) */
185/* 6 bytes */
186#define PEER_ENC_6BYTES_MIN ((1ULL << 32) | PEER_ENC_5BYTES_MIN) /* 0x1020408f0 (or 4328786160) */
187/* 7 bytes */
188#define PEER_ENC_7BYTES_MIN ((1ULL << 39) | PEER_ENC_6BYTES_MIN) /* 0x81020408f0 (or 554084600048) */
189/* 8 bytes */
190#define PEER_ENC_8BYTES_MIN ((1ULL << 46) | PEER_ENC_7BYTES_MIN) /* 0x4081020408f0 (or 70922828777712) */
191/* 9 bytes */
192#define PEER_ENC_9BYTES_MIN ((1ULL << 53) | PEER_ENC_8BYTES_MIN) /* 0x204081020408f0 (or 9078122083518704) */
193/* 10 bytes */
194#define PEER_ENC_10BYTES_MIN ((1ULL << 60) | PEER_ENC_9BYTES_MIN) /* 0x10204081020408f0 (or 1161999626690365680) */
195
196/* #7 bit used to detect the last byte to be encoded */
197#define PEER_ENC_STOP_BIT 7
198/* The byte minimum value with #7 bit set */
199#define PEER_ENC_STOP_BYTE (1 << PEER_ENC_STOP_BIT)
200/* The left most number of bits set for PEER_ENC_2BYTES_MIN */
201#define PEER_ENC_2BYTES_MIN_BITS 4
202
Frédéric Lécaille39143342019-05-24 14:32:27 +0200203#define PEER_MSG_HEADER_LEN 2
204
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200205#define PEER_STKT_CACHE_MAX_ENTRIES 128
206
Emeric Brun2b920a12010-09-23 18:30:22 +0200207/**********************************/
208/* Peer Session IO handler states */
209/**********************************/
210
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100211enum {
212 PEER_SESS_ST_ACCEPT = 0, /* Initial state for session create by an accept, must be zero! */
213 PEER_SESS_ST_GETVERSION, /* Validate supported protocol version */
214 PEER_SESS_ST_GETHOST, /* Validate host ID correspond to local host id */
215 PEER_SESS_ST_GETPEER, /* Validate peer ID correspond to a known remote peer id */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100216 /* after this point, data were possibly exchanged */
217 PEER_SESS_ST_SENDSUCCESS, /* Send ret code 200 (success) and wait for message */
218 PEER_SESS_ST_CONNECT, /* Initial state for session create on a connect, push presentation into buffer */
219 PEER_SESS_ST_GETSTATUS, /* Wait for the welcome message */
220 PEER_SESS_ST_WAITMSG, /* Wait for data messages */
221 PEER_SESS_ST_EXIT, /* Exit with status code */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200222 PEER_SESS_ST_ERRPROTO, /* Send error proto message before exit */
223 PEER_SESS_ST_ERRSIZE, /* Send error size message before exit */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100224 PEER_SESS_ST_END, /* Killed session */
225};
Emeric Brun2b920a12010-09-23 18:30:22 +0200226
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100227/***************************************************/
228/* Peer Session status code - part of the protocol */
229/***************************************************/
Emeric Brun2b920a12010-09-23 18:30:22 +0200230
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100231#define PEER_SESS_SC_CONNECTCODE 100 /* connect in progress */
232#define PEER_SESS_SC_CONNECTEDCODE 110 /* tcp connect success */
Emeric Brun2b920a12010-09-23 18:30:22 +0200233
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100234#define PEER_SESS_SC_SUCCESSCODE 200 /* accept or connect successful */
Emeric Brun2b920a12010-09-23 18:30:22 +0200235
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100236#define PEER_SESS_SC_TRYAGAIN 300 /* try again later */
Emeric Brun2b920a12010-09-23 18:30:22 +0200237
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100238#define PEER_SESS_SC_ERRPROTO 501 /* error protocol */
239#define PEER_SESS_SC_ERRVERSION 502 /* unknown protocol version */
240#define PEER_SESS_SC_ERRHOST 503 /* bad host name */
241#define PEER_SESS_SC_ERRPEER 504 /* unknown peer */
Emeric Brun2b920a12010-09-23 18:30:22 +0200242
243#define PEER_SESSION_PROTO_NAME "HAProxyS"
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200244#define PEER_MAJOR_VER 2
245#define PEER_MINOR_VER 1
246#define PEER_DWNGRD_MINOR_VER 0
Emeric Brun2b920a12010-09-23 18:30:22 +0200247
Willy Tarreau6254a922019-01-29 17:45:23 +0100248static size_t proto_len = sizeof(PEER_SESSION_PROTO_NAME) - 1;
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200249struct peers *cfg_peers = NULL;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200250static void peer_session_forceshutdown(struct peer *peer);
Emeric Brun2b920a12010-09-23 18:30:22 +0200251
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200252static struct ebpt_node *dcache_tx_insert(struct dcache *dc,
253 struct dcache_tx_entry *i);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200254static inline void flush_dcache(struct peer *peer);
255
Frédéric Lécaille95679dc2019-04-15 10:25:27 +0200256static const char *statuscode_str(int statuscode)
257{
258 switch (statuscode) {
259 case PEER_SESS_SC_CONNECTCODE:
260 return "CONN";
261 case PEER_SESS_SC_CONNECTEDCODE:
262 return "HSHK";
263 case PEER_SESS_SC_SUCCESSCODE:
264 return "ESTA";
265 case PEER_SESS_SC_TRYAGAIN:
266 return "RETR";
267 case PEER_SESS_SC_ERRPROTO:
268 return "PROT";
269 case PEER_SESS_SC_ERRVERSION:
270 return "VERS";
271 case PEER_SESS_SC_ERRHOST:
272 return "NAME";
273 case PEER_SESS_SC_ERRPEER:
274 return "UNKN";
275 default:
276 return "NONE";
277 }
278}
279
Emeric Brun18928af2017-03-29 16:32:53 +0200280/* This function encode an uint64 to 'dynamic' length format.
281 The encoded value is written at address *str, and the
282 caller must assure that size after *str is large enought.
283 At return, the *str is set at the next Byte after then
284 encoded integer. The function returns then length of the
285 encoded integer in Bytes */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200286int intencode(uint64_t i, char **str) {
287 int idx = 0;
288 unsigned char *msg;
289
Emeric Brunb3971ab2015-05-12 18:49:09 +0200290 msg = (unsigned char *)*str;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200291 if (i < PEER_ENC_2BYTES_MIN) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200292 msg[0] = (unsigned char)i;
293 *str = (char *)&msg[idx+1];
294 return (idx+1);
295 }
296
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200297 msg[idx] =(unsigned char)i | PEER_ENC_2BYTES_MIN;
298 i = (i - PEER_ENC_2BYTES_MIN) >> PEER_ENC_2BYTES_MIN_BITS;
299 while (i >= PEER_ENC_STOP_BYTE) {
300 msg[++idx] = (unsigned char)i | PEER_ENC_STOP_BYTE;
301 i = (i - PEER_ENC_STOP_BYTE) >> PEER_ENC_STOP_BIT;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200302 }
303 msg[++idx] = (unsigned char)i;
304 *str = (char *)&msg[idx+1];
305 return (idx+1);
306}
307
308
309/* This function returns the decoded integer or 0
310 if decode failed
311 *str point on the beginning of the integer to decode
312 at the end of decoding *str point on the end of the
313 encoded integer or to null if end is reached */
Emeric Brun18928af2017-03-29 16:32:53 +0200314uint64_t intdecode(char **str, char *end)
315{
Emeric Brunb3971ab2015-05-12 18:49:09 +0200316 unsigned char *msg;
Emeric Brun18928af2017-03-29 16:32:53 +0200317 uint64_t i;
318 int shift;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200319
320 if (!*str)
321 return 0;
322
323 msg = (unsigned char *)*str;
Emeric Brun18928af2017-03-29 16:32:53 +0200324 if (msg >= (unsigned char *)end)
325 goto fail;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200326
Emeric Brun18928af2017-03-29 16:32:53 +0200327 i = *(msg++);
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200328 if (i >= PEER_ENC_2BYTES_MIN) {
329 shift = PEER_ENC_2BYTES_MIN_BITS;
Emeric Brun18928af2017-03-29 16:32:53 +0200330 do {
331 if (msg >= (unsigned char *)end)
332 goto fail;
333 i += (uint64_t)*msg << shift;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200334 shift += PEER_ENC_STOP_BIT;
335 } while (*(msg++) >= PEER_ENC_STOP_BYTE);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200336 }
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100337 *str = (char *)msg;
338 return i;
Emeric Brun18928af2017-03-29 16:32:53 +0200339
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100340 fail:
341 *str = NULL;
342 return 0;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200343}
Emeric Brun2b920a12010-09-23 18:30:22 +0200344
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100345/*
346 * Build a "hello" peer protocol message.
347 * Return the number of written bytes written to build this messages if succeeded,
348 * 0 if not.
349 */
350static int peer_prepare_hellomsg(char *msg, size_t size, struct peer_prep_params *p)
351{
352 int min_ver, ret;
353 struct peer *peer;
354
355 peer = p->hello.peer;
356 min_ver = (peer->flags & PEER_F_DWNGRD) ? PEER_DWNGRD_MINOR_VER : PEER_MINOR_VER;
357 /* Prepare headers */
358 ret = snprintf(msg, size, PEER_SESSION_PROTO_NAME " %u.%u\n%s\n%s %d %d\n",
359 PEER_MAJOR_VER, min_ver, peer->id, localpeer, (int)getpid(), relative_pid);
360 if (ret >= size)
361 return 0;
362
363 return ret;
364}
365
366/*
367 * Build a "handshake succeeded" status message.
368 * Return the number of written bytes written to build this messages if succeeded,
369 * 0 if not.
370 */
371static int peer_prepare_status_successmsg(char *msg, size_t size, struct peer_prep_params *p)
372{
373 int ret;
374
375 ret = snprintf(msg, size, "%d\n", PEER_SESS_SC_SUCCESSCODE);
376 if (ret >= size)
377 return 0;
378
379 return ret;
380}
381
382/*
383 * Build an error status message.
384 * Return the number of written bytes written to build this messages if succeeded,
385 * 0 if not.
386 */
387static int peer_prepare_status_errormsg(char *msg, size_t size, struct peer_prep_params *p)
388{
389 int ret;
390 unsigned int st1;
391
392 st1 = p->error_status.st1;
393 ret = snprintf(msg, size, "%d\n", st1);
394 if (ret >= size)
395 return 0;
396
397 return ret;
398}
399
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200400/* Set the stick-table UPDATE message type byte at <msg_type> address,
401 * depending on <use_identifier> and <use_timed> boolean parameters.
402 * Always successful.
403 */
404static inline void peer_set_update_msg_type(char *msg_type, int use_identifier, int use_timed)
405{
406 if (use_timed) {
407 if (use_identifier)
408 *msg_type = PEER_MSG_STKT_UPDATE_TIMED;
409 else
410 *msg_type = PEER_MSG_STKT_INCUPDATE_TIMED;
411 }
412 else {
413 if (use_identifier)
414 *msg_type = PEER_MSG_STKT_UPDATE;
415 else
416 *msg_type = PEER_MSG_STKT_INCUPDATE;
417 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200418}
Emeric Brun2b920a12010-09-23 18:30:22 +0200419/*
Emeric Brunb3971ab2015-05-12 18:49:09 +0200420 * This prepare the data update message on the stick session <ts>, <st> is the considered
421 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800422 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200423 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
424 * check size)
Emeric Brun2b920a12010-09-23 18:30:22 +0200425 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100426static int peer_prepare_updatemsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brun2b920a12010-09-23 18:30:22 +0200427{
428 uint32_t netinteger;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200429 unsigned short datalen;
430 char *cursor, *datamsg;
Emeric Brun94900952015-06-11 18:25:54 +0200431 unsigned int data_type;
432 void *data_ptr;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100433 struct stksess *ts;
434 struct shared_table *st;
435 unsigned int updateid;
436 int use_identifier;
437 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200438 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100439
440 ts = p->updt.stksess;
441 st = p->updt.shared_table;
442 updateid = p->updt.updateid;
443 use_identifier = p->updt.use_identifier;
444 use_timed = p->updt.use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200445 peer = p->updt.peer;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200446
Frédéric Lécaille0e8db972019-05-24 14:34:34 +0200447 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200448
Emeric Brun2b920a12010-09-23 18:30:22 +0200449 /* construct message */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200450
451 /* check if we need to send the update identifer */
Emeric Brun819fc6f2017-06-13 19:37:32 +0200452 if (!st->last_pushed || updateid < st->last_pushed || ((updateid - st->last_pushed) != 1)) {
Emeric Bruna6a09982015-09-22 15:34:19 +0200453 use_identifier = 1;
Emeric Brun2b920a12010-09-23 18:30:22 +0200454 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200455
456 /* encode update identifier if needed */
457 if (use_identifier) {
Emeric Brun819fc6f2017-06-13 19:37:32 +0200458 netinteger = htonl(updateid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200459 memcpy(cursor, &netinteger, sizeof(netinteger));
460 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200461 }
462
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200463 if (use_timed) {
464 netinteger = htonl(tick_remain(now_ms, ts->expire));
465 memcpy(cursor, &netinteger, sizeof(netinteger));
466 cursor += sizeof(netinteger);
467 }
468
Emeric Brunb3971ab2015-05-12 18:49:09 +0200469 /* encode the key */
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200470 if (st->table->type == SMP_T_STR) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200471 int stlen = strlen((char *)ts->key.key);
472
Emeric Brunb3971ab2015-05-12 18:49:09 +0200473 intencode(stlen, &cursor);
474 memcpy(cursor, ts->key.key, stlen);
475 cursor += stlen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200476 }
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200477 else if (st->table->type == SMP_T_SINT) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200478 netinteger = htonl(*((uint32_t *)ts->key.key));
Emeric Brunb3971ab2015-05-12 18:49:09 +0200479 memcpy(cursor, &netinteger, sizeof(netinteger));
480 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200481 }
482 else {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200483 memcpy(cursor, ts->key.key, st->table->key_size);
484 cursor += st->table->key_size;
Emeric Brun2b920a12010-09-23 18:30:22 +0200485 }
486
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100487 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200488 /* encode values */
Emeric Brun94900952015-06-11 18:25:54 +0200489 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200490
Emeric Brun94900952015-06-11 18:25:54 +0200491 data_ptr = stktable_data_ptr(st->table, ts, data_type);
492 if (data_ptr) {
493 switch (stktable_data_types[data_type].std_type) {
494 case STD_T_SINT: {
495 int data;
496
497 data = stktable_data_cast(data_ptr, std_t_sint);
498 intencode(data, &cursor);
499 break;
500 }
501 case STD_T_UINT: {
502 unsigned int data;
503
504 data = stktable_data_cast(data_ptr, std_t_uint);
505 intencode(data, &cursor);
506 break;
507 }
508 case STD_T_ULL: {
509 unsigned long long data;
510
511 data = stktable_data_cast(data_ptr, std_t_ull);
512 intencode(data, &cursor);
513 break;
514 }
515 case STD_T_FRQP: {
516 struct freq_ctr_period *frqp;
517
518 frqp = &stktable_data_cast(data_ptr, std_t_frqp);
519 intencode((unsigned int)(now_ms - frqp->curr_tick), &cursor);
520 intencode(frqp->curr_ctr, &cursor);
521 intencode(frqp->prev_ctr, &cursor);
522 break;
523 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200524 case STD_T_DICT: {
525 struct dict_entry *de;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200526 struct ebpt_node *cached_de;
Willy Tarreau237f8ae2019-06-06 16:40:43 +0200527 struct dcache_tx_entry cde = { };
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200528 char *beg, *end;
529 size_t value_len, data_len;
530 struct dcache *dc;
531
532 de = stktable_data_cast(data_ptr, std_t_dict);
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100533 if (!de) {
534 /* No entry */
535 intencode(0, &cursor);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200536 break;
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +0100537 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200538
539 dc = peer->dcache;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200540 cde.entry.key = de;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200541 cached_de = dcache_tx_insert(dc, &cde);
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200542 if (cached_de == &cde.entry) {
543 if (cde.id + 1 >= PEER_ENC_2BYTES_MIN)
544 break;
545 /* Encode the length of the remaining data -> 1 */
546 intencode(1, &cursor);
547 /* Encode the cache entry ID */
548 intencode(cde.id + 1, &cursor);
549 }
550 else {
551 /* Leave enough room to encode the remaining data length. */
552 end = beg = cursor + PEER_MSG_ENC_LENGTH_MAXLEN;
553 /* Encode the dictionary entry key */
554 intencode(cde.id + 1, &end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200555 /* Encode the length of the dictionary entry data */
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200556 value_len = de->len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200557 intencode(value_len, &end);
558 /* Copy the data */
559 memcpy(end, de->value.key, value_len);
560 end += value_len;
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200561 /* Encode the length of the data */
562 data_len = end - beg;
563 intencode(data_len, &cursor);
564 memmove(cursor, beg, data_len);
565 cursor += data_len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200566 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200567 break;
568 }
Emeric Brun94900952015-06-11 18:25:54 +0200569 }
570 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200571 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100572 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200573
574 /* Compute datalen */
575 datalen = (cursor - datamsg);
576
577 /* prepare message header */
578 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200579 peer_set_update_msg_type(&msg[1], use_identifier, use_timed);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200580 cursor = &msg[2];
581 intencode(datalen, &cursor);
582
583 /* move data after header */
584 memmove(cursor, datamsg, datalen);
585
586 /* return header size + data_len */
587 return (cursor - msg) + datalen;
588}
589
590/*
591 * This prepare the switch table message to targeted share table <st>.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800592 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200593 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
594 * check size)
595 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100596static int peer_prepare_switchmsg(char *msg, size_t size, struct peer_prep_params *params)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200597{
598 int len;
599 unsigned short datalen;
Willy Tarreau83061a82018-07-13 11:56:34 +0200600 struct buffer *chunk;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200601 char *cursor, *datamsg, *chunkp, *chunkq;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200602 uint64_t data = 0;
Emeric Brun94900952015-06-11 18:25:54 +0200603 unsigned int data_type;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100604 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200605
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100606 st = params->swtch.shared_table;
Frédéric Lécaille39143342019-05-24 14:32:27 +0200607 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200608
609 /* Encode data */
610
611 /* encode local id */
612 intencode(st->local_id, &cursor);
613
614 /* encode table name */
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100615 len = strlen(st->table->nid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200616 intencode(len, &cursor);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100617 memcpy(cursor, st->table->nid, len);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200618 cursor += len;
619
620 /* encode table type */
621
622 intencode(st->table->type, &cursor);
623
624 /* encode table key size */
625 intencode(st->table->key_size, &cursor);
626
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200627 chunk = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200628 chunkp = chunkq = chunk->area;
Emeric Brun94900952015-06-11 18:25:54 +0200629 /* encode available known data types in table */
630 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
631 if (st->table->data_ofs[data_type]) {
632 switch (stktable_data_types[data_type].std_type) {
633 case STD_T_SINT:
634 case STD_T_UINT:
635 case STD_T_ULL:
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200636 case STD_T_DICT:
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200637 data |= 1 << data_type;
638 break;
Emeric Brun94900952015-06-11 18:25:54 +0200639 case STD_T_FRQP:
640 data |= 1 << data_type;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200641 intencode(data_type, &chunkq);
642 intencode(st->table->data_arg[data_type].u, &chunkq);
Emeric Brun94900952015-06-11 18:25:54 +0200643 break;
644 }
645 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200646 }
647 intencode(data, &cursor);
648
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200649 /* Encode stick-table entries duration. */
650 intencode(st->table->expire, &cursor);
651
652 if (chunkq > chunkp) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200653 chunk->data = chunkq - chunkp;
654 memcpy(cursor, chunk->area, chunk->data);
655 cursor += chunk->data;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200656 }
657
Emeric Brunb3971ab2015-05-12 18:49:09 +0200658 /* Compute datalen */
659 datalen = (cursor - datamsg);
Emeric Brun2b920a12010-09-23 18:30:22 +0200660
Emeric Brunb3971ab2015-05-12 18:49:09 +0200661 /* prepare message header */
662 msg[0] = PEER_MSG_CLASS_STICKTABLE;
663 msg[1] = PEER_MSG_STKT_DEFINE;
664 cursor = &msg[2];
665 intencode(datalen, &cursor);
Emeric Brun2b920a12010-09-23 18:30:22 +0200666
Emeric Brunb3971ab2015-05-12 18:49:09 +0200667 /* move data after header */
668 memmove(cursor, datamsg, datalen);
669
670 /* return header size + data_len */
671 return (cursor - msg) + datalen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200672}
673
Emeric Brunb3971ab2015-05-12 18:49:09 +0200674/*
675 * This prepare the acknowledge message on the stick session <ts>, <st> is the considered
676 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800677 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200678 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
679 * check size)
680 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100681static int peer_prepare_ackmsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200682{
683 unsigned short datalen;
684 char *cursor, *datamsg;
685 uint32_t netinteger;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100686 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200687
Frédéric Lécaille39143342019-05-24 14:32:27 +0200688 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200689
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100690 st = p->ack.shared_table;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200691 intencode(st->remote_id, &cursor);
692 netinteger = htonl(st->last_get);
693 memcpy(cursor, &netinteger, sizeof(netinteger));
694 cursor += sizeof(netinteger);
695
696 /* Compute datalen */
697 datalen = (cursor - datamsg);
698
699 /* prepare message header */
700 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Emeric Brune1ab8082015-08-21 11:48:54 +0200701 msg[1] = PEER_MSG_STKT_ACK;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200702 cursor = &msg[2];
703 intencode(datalen, &cursor);
704
705 /* move data after header */
706 memmove(cursor, datamsg, datalen);
707
708 /* return header size + data_len */
709 return (cursor - msg) + datalen;
710}
Emeric Brun2b920a12010-09-23 18:30:22 +0200711
712/*
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200713 * Function to deinit connected peer
714 */
715void __peer_session_deinit(struct peer *peer)
716{
717 struct stream_interface *si;
718 struct stream *s;
719 struct peers *peers;
720
721 if (!peer->appctx)
722 return;
723
724 si = peer->appctx->owner;
725 if (!si)
726 return;
727
728 s = si_strm(si);
729 if (!s)
730 return;
731
732 peers = strm_fe(s)->parent;
733 if (!peers)
734 return;
735
736 if (peer->appctx->st0 == PEER_SESS_ST_WAITMSG)
737 HA_ATOMIC_SUB(&connected_peers, 1);
738
739 HA_ATOMIC_SUB(&active_peers, 1);
740
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200741 flush_dcache(peer);
742
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200743 /* Re-init current table pointers to force announcement on re-connect */
744 peer->remote_table = peer->last_local_table = NULL;
745 peer->appctx = NULL;
746 if (peer->flags & PEER_F_LEARN_ASSIGN) {
747 /* unassign current peer for learning */
748 peer->flags &= ~(PEER_F_LEARN_ASSIGN);
749 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
750
751 /* reschedule a resync */
752 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
753 }
754 /* reset teaching and learning flags to 0 */
755 peer->flags &= PEER_TEACH_RESET;
756 peer->flags &= PEER_LEARN_RESET;
Frédéric Lécaille3585cab2019-11-20 11:17:30 +0100757 /* set this peer as dead from heartbeat point of view */
758 peer->flags &= ~PEER_F_ALIVE;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200759 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
760}
761
762/*
Emeric Brun2b920a12010-09-23 18:30:22 +0200763 * Callback to release a session with a peer
764 */
Willy Tarreau00a37f02015-04-13 12:05:19 +0200765static void peer_session_release(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +0200766{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200767 struct peer *peer = appctx->ctx.peers.ptr;
Emeric Brun2b920a12010-09-23 18:30:22 +0200768
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100769 /* appctx->ctx.peers.ptr is not a peer session */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100770 if (appctx->st0 < PEER_SESS_ST_SENDSUCCESS)
Emeric Brun2b920a12010-09-23 18:30:22 +0200771 return;
772
773 /* peer session identified */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200774 if (peer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100775 HA_SPIN_LOCK(PEER_LOCK, &peer->lock);
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200776 if (peer->appctx == appctx)
777 __peer_session_deinit(peer);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100778 HA_SPIN_UNLOCK(PEER_LOCK, &peer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +0200779 }
780}
781
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200782/* Retrieve the major and minor versions of peers protocol
783 * announced by a remote peer. <str> is a null-terminated
784 * string with the following format: "<maj_ver>.<min_ver>".
785 */
786static int peer_get_version(const char *str,
787 unsigned int *maj_ver, unsigned int *min_ver)
788{
789 unsigned int majv, minv;
790 const char *pos, *saved;
791 const char *end;
792
793 saved = pos = str;
794 end = str + strlen(str);
795
796 majv = read_uint(&pos, end);
797 if (saved == pos || *pos++ != '.')
798 return -1;
799
800 saved = pos;
801 minv = read_uint(&pos, end);
802 if (saved == pos || pos != end)
803 return -1;
804
805 *maj_ver = majv;
806 *min_ver = minv;
807
808 return 0;
809}
Emeric Brun2b920a12010-09-23 18:30:22 +0200810
811/*
Frédéric Lécaillece025572019-01-21 13:38:06 +0100812 * Parse a line terminated by an optional '\r' character, followed by a mandatory
813 * '\n' character.
814 * Returns 1 if succeeded or 0 if a '\n' character could not be found, and -1 if
815 * a line could not be read because the communication channel is closed.
816 */
817static inline int peer_getline(struct appctx *appctx)
818{
819 int n;
820 struct stream_interface *si = appctx->owner;
821
822 n = co_getline(si_oc(si), trash.area, trash.size);
823 if (!n)
824 return 0;
825
826 if (n < 0 || trash.area[n - 1] != '\n') {
827 appctx->st0 = PEER_SESS_ST_END;
828 return -1;
829 }
830
831 if (n > 1 && (trash.area[n - 2] == '\r'))
832 trash.area[n - 2] = 0;
833 else
834 trash.area[n - 1] = 0;
835
836 co_skip(si_oc(si), n);
837
838 return n;
839}
840
841/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100842 * Send a message after having called <peer_prepare_msg> to build it.
843 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
844 * Returns -1 if there was not enough room left to send the message,
845 * any other negative returned value must be considered as an error with an appcxt st0
846 * returned value equal to PEER_SESS_ST_END.
847 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100848static inline int peer_send_msg(struct appctx *appctx,
849 int (*peer_prepare_msg)(char *, size_t, struct peer_prep_params *),
850 struct peer_prep_params *params)
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100851{
852 int ret, msglen;
853 struct stream_interface *si = appctx->owner;
854
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100855 msglen = peer_prepare_msg(trash.area, trash.size, params);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100856 if (!msglen) {
857 /* internal error: message does not fit in trash */
858 appctx->st0 = PEER_SESS_ST_END;
859 return 0;
860 }
861
862 /* message to buffer */
863 ret = ci_putblk(si_ic(si), trash.area, msglen);
864 if (ret <= 0) {
865 if (ret == -1) {
866 /* No more write possible */
867 si_rx_room_blk(si);
868 return -1;
869 }
870 appctx->st0 = PEER_SESS_ST_END;
871 }
872
873 return ret;
874}
875
876/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100877 * Send a hello message.
878 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
879 * Returns -1 if there was not enough room left to send the message,
880 * any other negative returned value must be considered as an error with an appcxt st0
881 * returned value equal to PEER_SESS_ST_END.
882 */
883static inline int peer_send_hellomsg(struct appctx *appctx, struct peer *peer)
884{
885 struct peer_prep_params p = {
886 .hello.peer = peer,
887 };
888
889 return peer_send_msg(appctx, peer_prepare_hellomsg, &p);
890}
891
892/*
893 * Send a success peer handshake status message.
894 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
895 * Returns -1 if there was not enough room left to send the message,
896 * any other negative returned value must be considered as an error with an appcxt st0
897 * returned value equal to PEER_SESS_ST_END.
898 */
899static inline int peer_send_status_successmsg(struct appctx *appctx)
900{
901 return peer_send_msg(appctx, peer_prepare_status_successmsg, NULL);
902}
903
904/*
905 * Send a peer handshake status error message.
906 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
907 * Returns -1 if there was not enough room left to send the message,
908 * any other negative returned value must be considered as an error with an appcxt st0
909 * returned value equal to PEER_SESS_ST_END.
910 */
911static inline int peer_send_status_errormsg(struct appctx *appctx)
912{
913 struct peer_prep_params p = {
914 .error_status.st1 = appctx->st1,
915 };
916
917 return peer_send_msg(appctx, peer_prepare_status_errormsg, &p);
918}
919
920/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100921 * Send a stick-table switch message.
922 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
923 * Returns -1 if there was not enough room left to send the message,
924 * any other negative returned value must be considered as an error with an appcxt st0
925 * returned value equal to PEER_SESS_ST_END.
926 */
927static inline int peer_send_switchmsg(struct shared_table *st, struct appctx *appctx)
928{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100929 struct peer_prep_params p = {
930 .swtch.shared_table = st,
931 };
932
933 return peer_send_msg(appctx, peer_prepare_switchmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100934}
935
936/*
937 * Send a stick-table update acknowledgement message.
938 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
939 * Returns -1 if there was not enough room left to send the message,
940 * any other negative returned value must be considered as an error with an appcxt st0
941 * returned value equal to PEER_SESS_ST_END.
942 */
943static inline int peer_send_ackmsg(struct shared_table *st, struct appctx *appctx)
944{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100945 struct peer_prep_params p = {
946 .ack.shared_table = st,
947 };
948
949 return peer_send_msg(appctx, peer_prepare_ackmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100950}
951
952/*
Frédéric Lécaille87f554c2019-01-22 17:26:50 +0100953 * Send a stick-table update message.
954 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
955 * Returns -1 if there was not enough room left to send the message,
956 * any other negative returned value must be considered as an error with an appcxt st0
957 * returned value equal to PEER_SESS_ST_END.
958 */
959static inline int peer_send_updatemsg(struct shared_table *st, struct appctx *appctx, struct stksess *ts,
960 unsigned int updateid, int use_identifier, int use_timed)
961{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100962 struct peer_prep_params p = {
963 .updt.stksess = ts,
964 .updt.shared_table = st,
965 .updt.updateid = updateid,
966 .updt.use_identifier = use_identifier,
967 .updt.use_timed = use_timed,
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200968 .updt.peer = appctx->ctx.peers.ptr,
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100969 };
970
971 return peer_send_msg(appctx, peer_prepare_updatemsg, &p);
Frédéric Lécaille87f554c2019-01-22 17:26:50 +0100972}
973
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100974/*
975 * Build a peer protocol control class message.
976 * Returns the number of written bytes used to build the message if succeeded,
977 * 0 if not.
978 */
979static int peer_prepare_control_msg(char *msg, size_t size, struct peer_prep_params *p)
980{
981 if (size < sizeof p->control.head)
982 return 0;
983
984 msg[0] = p->control.head[0];
985 msg[1] = p->control.head[1];
986
987 return 2;
988}
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +0100989
990/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100991 * Send a stick-table synchronization request 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 appctx st0
995 * returned value equal to PEER_SESS_ST_END.
996 */
997static inline int peer_send_resync_reqmsg(struct appctx *appctx)
998{
999 struct peer_prep_params p = {
1000 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCREQ, },
1001 };
1002
1003 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1004}
1005
1006/*
1007 * Send a stick-table synchronization confirmation message.
1008 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1009 * Returns -1 if there was not enough room left to send the message,
1010 * any other negative returned value must be considered as an error with an appctx st0
1011 * returned value equal to PEER_SESS_ST_END.
1012 */
1013static inline int peer_send_resync_confirmsg(struct appctx *appctx)
1014{
1015 struct peer_prep_params p = {
1016 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCCONFIRM, },
1017 };
1018
1019 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1020}
1021
1022/*
1023 * Send a stick-table synchronization finished message.
1024 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1025 * Returns -1 if there was not enough room left to send the message,
1026 * any other negative returned value must be considered as an error with an appctx st0
1027 * returned value equal to PEER_SESS_ST_END.
1028 */
1029static inline int peer_send_resync_finishedmsg(struct appctx *appctx, struct peer *peer)
1030{
1031 struct peer_prep_params p = {
1032 .control.head = { PEER_MSG_CLASS_CONTROL, },
1033 };
1034
1035 p.control.head[1] = (peer->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED ?
1036 PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
1037
1038 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1039}
1040
1041/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001042 * Send a heartbeat message.
1043 * Return 0 if the message could not be built modifying the appctx st0 to PEER_SESS_ST_END value.
1044 * Returns -1 if there was not enough room left to send the message,
1045 * any other negative returned value must be considered as an error with an appctx st0
1046 * returned value equal to PEER_SESS_ST_END.
1047 */
1048static inline int peer_send_heartbeatmsg(struct appctx *appctx)
1049{
1050 struct peer_prep_params p = {
1051 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_HEARTBEAT, },
1052 };
1053
1054 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1055}
1056
1057/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001058 * Build a peer protocol error class message.
1059 * Returns the number of written bytes used to build the message if succeeded,
1060 * 0 if not.
1061 */
1062static int peer_prepare_error_msg(char *msg, size_t size, struct peer_prep_params *p)
1063{
1064 if (size < sizeof p->error.head)
1065 return 0;
1066
1067 msg[0] = p->error.head[0];
1068 msg[1] = p->error.head[1];
1069
1070 return 2;
1071}
1072
1073/*
1074 * Send a "size limit reached" error message.
1075 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1076 * Returns -1 if there was not enough room left to send the message,
1077 * any other negative returned value must be considered as an error with an appctx st0
1078 * returned value equal to PEER_SESS_ST_END.
1079 */
1080static inline int peer_send_error_size_limitmsg(struct appctx *appctx)
1081{
1082 struct peer_prep_params p = {
1083 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_SIZELIMIT, },
1084 };
1085
1086 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1087}
1088
1089/*
1090 * Send a "peer protocol" error message.
1091 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1092 * Returns -1 if there was not enough room left to send the message,
1093 * any other negative returned value must be considered as an error with an appctx st0
1094 * returned value equal to PEER_SESS_ST_END.
1095 */
1096static inline int peer_send_error_protomsg(struct appctx *appctx)
1097{
1098 struct peer_prep_params p = {
1099 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_PROTOCOL, },
1100 };
1101
1102 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1103}
1104
1105/*
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001106 * Function used to lookup for recent stick-table updates associated with
1107 * <st> shared stick-table when a lesson must be taught a peer (PEER_F_LEARN_ASSIGN flag set).
1108 */
1109static inline struct stksess *peer_teach_process_stksess_lookup(struct shared_table *st)
1110{
1111 struct eb32_node *eb;
1112
1113 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1114 if (!eb) {
1115 eb = eb32_first(&st->table->updates);
1116 if (!eb || ((int)(eb->key - st->last_pushed) <= 0)) {
1117 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1118 return NULL;
1119 }
1120 }
1121
1122 if ((int)(eb->key - st->table->localupdate) > 0) {
1123 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1124 return NULL;
1125 }
1126
1127 return eb32_entry(eb, struct stksess, upd);
1128}
1129
1130/*
1131 * Function used to lookup for recent stick-table updates associated with
1132 * <st> shared stick-table during teach state 1 step.
1133 */
1134static inline struct stksess *peer_teach_stage1_stksess_lookup(struct shared_table *st)
1135{
1136 struct eb32_node *eb;
1137
1138 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1139 if (!eb) {
1140 st->flags |= SHTABLE_F_TEACH_STAGE1;
1141 eb = eb32_first(&st->table->updates);
1142 if (eb)
1143 st->last_pushed = eb->key - 1;
1144 return NULL;
1145 }
1146
1147 return eb32_entry(eb, struct stksess, upd);
1148}
1149
1150/*
1151 * Function used to lookup for recent stick-table updates associated with
1152 * <st> shared stick-table during teach state 2 step.
1153 */
1154static inline struct stksess *peer_teach_stage2_stksess_lookup(struct shared_table *st)
1155{
1156 struct eb32_node *eb;
1157
1158 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1159 if (!eb || eb->key > st->teaching_origin) {
1160 st->flags |= SHTABLE_F_TEACH_STAGE2;
1161 return NULL;
1162 }
1163
1164 return eb32_entry(eb, struct stksess, upd);
1165}
1166
1167/*
1168 * Generic function to emit update messages for <st> stick-table when a lesson must
1169 * be taught to the peer <p>.
1170 * <locked> must be set to 1 if the shared table <st> is already locked when entering
1171 * this function, 0 if not.
1172 *
1173 * This function temporary unlock/lock <st> when it sends stick-table updates or
1174 * when decrementing its refcount in case of any error when it sends this updates.
1175 *
1176 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1177 * Returns -1 if there was not enough room left to send the message,
1178 * any other negative returned value must be considered as an error with an appcxt st0
1179 * returned value equal to PEER_SESS_ST_END.
1180 * If it returns 0 or -1, this function leave <st> locked if already locked when entering this function
1181 * unlocked if not already locked when entering this function.
1182 */
1183static inline int peer_send_teachmsgs(struct appctx *appctx, struct peer *p,
1184 struct stksess *(*peer_stksess_lookup)(struct shared_table *),
1185 struct shared_table *st, int locked)
1186{
1187 int ret, new_pushed, use_timed;
1188
1189 ret = 1;
1190 use_timed = 0;
1191 if (st != p->last_local_table) {
1192 ret = peer_send_switchmsg(st, appctx);
1193 if (ret <= 0)
1194 return ret;
1195
1196 p->last_local_table = st;
1197 }
1198
1199 if (peer_stksess_lookup != peer_teach_process_stksess_lookup)
1200 use_timed = !(p->flags & PEER_F_DWNGRD);
1201
1202 /* We force new pushed to 1 to force identifier in update message */
1203 new_pushed = 1;
1204
1205 if (!locked)
1206 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1207
1208 while (1) {
1209 struct stksess *ts;
1210 unsigned updateid;
1211
1212 /* push local updates */
1213 ts = peer_stksess_lookup(st);
1214 if (!ts)
1215 break;
1216
1217 updateid = ts->upd.key;
1218 ts->ref_cnt++;
1219 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1220
1221 ret = peer_send_updatemsg(st, appctx, ts, updateid, new_pushed, use_timed);
1222 if (ret <= 0) {
1223 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1224 ts->ref_cnt--;
1225 if (!locked)
1226 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1227 return ret;
1228 }
1229
1230 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1231 ts->ref_cnt--;
1232 st->last_pushed = updateid;
1233
1234 if (peer_stksess_lookup == peer_teach_process_stksess_lookup &&
1235 (int)(st->last_pushed - st->table->commitupdate) > 0)
1236 st->table->commitupdate = st->last_pushed;
1237
1238 /* identifier may not needed in next update message */
1239 new_pushed = 0;
1240 }
1241
1242 out:
1243 if (!locked)
1244 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1245 return 1;
1246}
1247
1248/*
1249 * Function to emit update messages for <st> stick-table when a lesson must
1250 * be taught to the peer <p> (PEER_F_LEARN_ASSIGN flag set).
1251 *
1252 * Note that <st> shared stick-table is locked when calling this function.
1253 *
1254 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1255 * Returns -1 if there was not enough room left to send the message,
1256 * any other negative returned value must be considered as an error with an appcxt st0
1257 * returned value equal to PEER_SESS_ST_END.
1258 */
1259static inline int peer_send_teach_process_msgs(struct appctx *appctx, struct peer *p,
1260 struct shared_table *st)
1261{
1262 return peer_send_teachmsgs(appctx, p, peer_teach_process_stksess_lookup, st, 1);
1263}
1264
1265/*
1266 * Function to emit update messages for <st> stick-table when a lesson must
1267 * be taught to the peer <p> during teach state 1 step.
1268 *
1269 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1270 * Returns -1 if there was not enough room left to send the message,
1271 * any other negative returned value must be considered as an error with an appcxt st0
1272 * returned value equal to PEER_SESS_ST_END.
1273 */
1274static inline int peer_send_teach_stage1_msgs(struct appctx *appctx, struct peer *p,
1275 struct shared_table *st)
1276{
1277 return peer_send_teachmsgs(appctx, p, peer_teach_stage1_stksess_lookup, st, 0);
1278}
1279
1280/*
1281 * Function to emit update messages for <st> stick-table when a lesson must
1282 * be taught to the peer <p> during teach state 1 step.
1283 *
1284 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1285 * Returns -1 if there was not enough room left to send the message,
1286 * any other negative returned value must be considered as an error with an appcxt st0
1287 * returned value equal to PEER_SESS_ST_END.
1288 */
1289static inline int peer_send_teach_stage2_msgs(struct appctx *appctx, struct peer *p,
1290 struct shared_table *st)
1291{
1292 return peer_send_teachmsgs(appctx, p, peer_teach_stage2_stksess_lookup, st, 0);
1293}
1294
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001295
1296/*
1297 * Function used to parse a stick-table update message after it has been received
1298 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1299 * receipt buffer with <msg_end> being position of the end of the stick-table message.
1300 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1301 * was encountered.
1302 * <exp> must be set if the stick-table entry expires.
1303 * <updt> must be set for PEER_MSG_STKT_UPDATE or PEER_MSG_STKT_UPDATE_TIMED stick-table
1304 * messages, in this case the stick-table udpate message is received with a stick-table
1305 * update ID.
1306 * <totl> is the length of the stick-table update message computed upon receipt.
1307 */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001308static int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int exp,
1309 char **msg_cur, char *msg_end, int msg_len, int totl)
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001310{
1311 struct stream_interface *si = appctx->owner;
1312 struct shared_table *st = p->remote_table;
1313 struct stksess *ts, *newts;
1314 uint32_t update;
1315 int expire;
1316 unsigned int data_type;
1317 void *data_ptr;
1318
1319 /* Here we have data message */
1320 if (!st)
1321 goto ignore_msg;
1322
1323 expire = MS_TO_TICKS(st->table->expire);
1324
1325 if (updt) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001326 if (msg_len < sizeof(update))
1327 goto malformed_exit;
1328
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001329 memcpy(&update, *msg_cur, sizeof(update));
1330 *msg_cur += sizeof(update);
1331 st->last_get = htonl(update);
1332 }
1333 else {
1334 st->last_get++;
1335 }
1336
1337 if (exp) {
1338 size_t expire_sz = sizeof expire;
1339
Willy Tarreau1e82a142019-01-29 11:08:06 +01001340 if (*msg_cur + expire_sz > msg_end)
1341 goto malformed_exit;
1342
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001343 memcpy(&expire, *msg_cur, expire_sz);
1344 *msg_cur += expire_sz;
1345 expire = ntohl(expire);
1346 }
1347
1348 newts = stksess_new(st->table, NULL);
1349 if (!newts)
1350 goto ignore_msg;
1351
1352 if (st->table->type == SMP_T_STR) {
1353 unsigned int to_read, to_store;
1354
1355 to_read = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001356 if (!*msg_cur)
1357 goto malformed_free_newts;
1358
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001359 to_store = MIN(to_read, st->table->key_size - 1);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001360 if (*msg_cur + to_store > msg_end)
1361 goto malformed_free_newts;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001362
1363 memcpy(newts->key.key, *msg_cur, to_store);
1364 newts->key.key[to_store] = 0;
1365 *msg_cur += to_read;
1366 }
1367 else if (st->table->type == SMP_T_SINT) {
1368 unsigned int netinteger;
1369
Willy Tarreau1e82a142019-01-29 11:08:06 +01001370 if (*msg_cur + sizeof(netinteger) > msg_end)
1371 goto malformed_free_newts;
1372
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001373 memcpy(&netinteger, *msg_cur, sizeof(netinteger));
1374 netinteger = ntohl(netinteger);
1375 memcpy(newts->key.key, &netinteger, sizeof(netinteger));
1376 *msg_cur += sizeof(netinteger);
1377 }
1378 else {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001379 if (*msg_cur + st->table->key_size > msg_end)
1380 goto malformed_free_newts;
1381
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001382 memcpy(newts->key.key, *msg_cur, st->table->key_size);
1383 *msg_cur += st->table->key_size;
1384 }
1385
1386 /* lookup for existing entry */
1387 ts = stktable_set_entry(st->table, newts);
1388 if (ts != newts) {
1389 stksess_free(st->table, newts);
1390 newts = NULL;
1391 }
1392
1393 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
1394
1395 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001396 uint64_t decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001397
1398 if (!((1 << data_type) & st->remote_data))
1399 continue;
1400
Willy Tarreau1e82a142019-01-29 11:08:06 +01001401 decoded_int = intdecode(msg_cur, msg_end);
1402 if (!*msg_cur)
1403 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001404
Willy Tarreau1e82a142019-01-29 11:08:06 +01001405 switch (stktable_data_types[data_type].std_type) {
1406 case STD_T_SINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001407 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1408 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001409 stktable_data_cast(data_ptr, std_t_sint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001410 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001411
Willy Tarreau1e82a142019-01-29 11:08:06 +01001412 case STD_T_UINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001413 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1414 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001415 stktable_data_cast(data_ptr, std_t_uint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001416 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001417
Willy Tarreau1e82a142019-01-29 11:08:06 +01001418 case STD_T_ULL:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001419 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1420 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001421 stktable_data_cast(data_ptr, std_t_ull) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001422 break;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001423
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001424 case STD_T_FRQP: {
1425 struct freq_ctr_period data;
1426
1427 /* First bit is reserved for the freq_ctr_period lock
1428 Note: here we're still protected by the stksess lock
1429 so we don't need to update the update the freq_ctr_period
1430 using its internal lock */
1431
Willy Tarreau1e82a142019-01-29 11:08:06 +01001432 data.curr_tick = tick_add(now_ms, -decoded_int) & ~0x1;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001433 data.curr_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001434 if (!*msg_cur)
1435 goto malformed_unlock;
1436
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001437 data.prev_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001438 if (!*msg_cur)
1439 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001440
1441 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1442 if (data_ptr)
1443 stktable_data_cast(data_ptr, std_t_frqp) = data;
1444 break;
1445 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001446 case STD_T_DICT: {
1447 struct buffer *chunk;
1448 size_t data_len, value_len;
1449 unsigned int id;
1450 struct dict_entry *de;
1451 struct dcache *dc;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001452 char *end;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001453
Frédéric Lécailleaf9990f2019-11-13 17:50:34 +01001454 if (!decoded_int) {
1455 /* No entry. */
1456 break;
1457 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001458 data_len = decoded_int;
1459 if (*msg_cur + data_len > msg_end)
1460 goto malformed_unlock;
1461
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001462 /* Compute the end of the current data, <msg_end> being at the end of
1463 * the entire message.
1464 */
1465 end = *msg_cur + data_len;
1466 id = intdecode(msg_cur, end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001467 if (!*msg_cur || !id)
1468 goto malformed_unlock;
1469
1470 dc = p->dcache;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001471 if (*msg_cur == end) {
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001472 /* Dictionary entry key without value. */
1473 if (id > dc->max_entries)
1474 break;
1475 /* IDs sent over the network are numbered from 1. */
1476 de = dc->rx[id - 1].de;
1477 }
1478 else {
1479 chunk = get_trash_chunk();
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001480 value_len = intdecode(msg_cur, end);
1481 if (!*msg_cur || *msg_cur + value_len > end ||
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001482 unlikely(value_len + 1 >= chunk->size))
1483 goto malformed_unlock;
1484
1485 chunk_memcpy(chunk, *msg_cur, value_len);
1486 chunk->area[chunk->data] = '\0';
Frédéric Lécaille56aec0d2019-06-06 14:14:15 +02001487 *msg_cur += value_len;
1488
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001489 de = dict_insert(&server_name_dict, chunk->area);
1490 dc->rx[id - 1].de = de;
1491 }
1492 if (de) {
1493 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1494 if (data_ptr)
1495 stktable_data_cast(data_ptr, std_t_dict) = de;
1496 }
1497 break;
1498 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001499 }
1500 }
1501 /* Force new expiration */
1502 ts->expire = tick_add(now_ms, expire);
1503
1504 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1505 stktable_touch_remote(st->table, ts, 1);
1506 return 1;
1507
1508 ignore_msg:
1509 /* skip consumed message */
1510 co_skip(si_oc(si), totl);
1511 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001512
1513 malformed_unlock:
1514 /* malformed message */
1515 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1516 stktable_touch_remote(st->table, ts, 1);
1517 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1518 return 0;
1519
1520 malformed_free_newts:
1521 /* malformed message */
1522 stksess_free(st->table, newts);
1523 malformed_exit:
1524 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1525 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001526}
1527
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001528/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001529 * Function used to parse a stick-table update acknowledgement message after it
1530 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1531 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1532 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1533 * was encountered.
1534 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1535 */
1536static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1537 char **msg_cur, char *msg_end)
1538{
1539 /* ack message */
1540 uint32_t table_id ;
1541 uint32_t update;
1542 struct shared_table *st;
1543
1544 table_id = intdecode(msg_cur, msg_end);
1545 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1546 /* malformed message */
1547 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1548 return 0;
1549 }
1550
1551 memcpy(&update, *msg_cur, sizeof(update));
1552 update = ntohl(update);
1553
1554 for (st = p->tables; st; st = st->next) {
1555 if (st->local_id == table_id) {
1556 st->update = update;
1557 break;
1558 }
1559 }
1560
1561 return 1;
1562}
1563
1564/*
1565 * Function used to parse a stick-table switch message after it has been received
1566 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1567 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1568 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1569 * was encountered.
1570 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1571 */
1572static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1573 char **msg_cur, char *msg_end)
1574{
1575 struct shared_table *st;
1576 int table_id;
1577
1578 table_id = intdecode(msg_cur, msg_end);
1579 if (!*msg_cur) {
1580 /* malformed message */
1581 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1582 return 0;
1583 }
1584
1585 p->remote_table = NULL;
1586 for (st = p->tables; st; st = st->next) {
1587 if (st->remote_id == table_id) {
1588 p->remote_table = st;
1589 break;
1590 }
1591 }
1592
1593 return 1;
1594}
1595
1596/*
1597 * Function used to parse a stick-table definition message after it has been received
1598 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1599 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1600 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1601 * was encountered.
1602 * <totl> is the length of the stick-table update message computed upon receipt.
1603 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1604 */
1605static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1606 char **msg_cur, char *msg_end, int totl)
1607{
1608 struct stream_interface *si = appctx->owner;
1609 int table_id_len;
1610 struct shared_table *st;
1611 int table_type;
1612 int table_keylen;
1613 int table_id;
1614 uint64_t table_data;
1615
1616 table_id = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001617 if (!*msg_cur)
1618 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001619
1620 table_id_len = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001621 if (!*msg_cur)
1622 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001623
1624 p->remote_table = NULL;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001625 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end)
1626 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001627
1628 for (st = p->tables; st; st = st->next) {
1629 /* Reset IDs */
1630 if (st->remote_id == table_id)
1631 st->remote_id = 0;
1632
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001633 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1634 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001635 p->remote_table = st;
1636 }
1637
1638 if (!p->remote_table)
1639 goto ignore_msg;
1640
1641 *msg_cur += table_id_len;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001642 if (*msg_cur >= msg_end)
1643 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001644
1645 table_type = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001646 if (!*msg_cur)
1647 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001648
1649 table_keylen = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001650 if (!*msg_cur)
1651 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001652
1653 table_data = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001654 if (!*msg_cur)
1655 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001656
1657 if (p->remote_table->table->type != table_type
1658 || p->remote_table->table->key_size != table_keylen) {
1659 p->remote_table = NULL;
1660 goto ignore_msg;
1661 }
1662
1663 p->remote_table->remote_data = table_data;
1664 p->remote_table->remote_id = table_id;
1665 return 1;
1666
1667 ignore_msg:
1668 co_skip(si_oc(si), totl);
1669 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001670
1671 malformed_exit:
1672 /* malformed message */
1673 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1674 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001675}
1676
1677/*
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001678 * Receive a stick-table message.
1679 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1680 * -1 if there was an error updating the appctx state st0 accordingly.
1681 */
1682static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1683 uint32_t *msg_len, int *totl)
1684{
1685 int reql;
1686 struct stream_interface *si = appctx->owner;
1687
1688 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1689 if (reql <= 0) /* closed or EOL not found */
1690 goto incomplete;
1691
1692 *totl += reql;
1693
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001694 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001695 return 1;
1696
1697 /* Read and Decode message length */
1698 reql = co_getblk(si_oc(si), &msg_head[2], sizeof(char), *totl);
1699 if (reql <= 0) /* closed */
1700 goto incomplete;
1701
1702 *totl += reql;
1703
Frédéric Lécaille32b55732019-06-03 18:29:51 +02001704 if ((unsigned int)msg_head[2] < PEER_ENC_2BYTES_MIN) {
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001705 *msg_len = msg_head[2];
1706 }
1707 else {
1708 int i;
1709 char *cur;
1710 char *end;
1711
1712 for (i = 3 ; i < msg_head_sz ; i++) {
1713 reql = co_getblk(si_oc(si), &msg_head[i], sizeof(char), *totl);
1714 if (reql <= 0) /* closed */
1715 goto incomplete;
1716
1717 *totl += reql;
1718
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001719 if (!(msg_head[i] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001720 break;
1721 }
1722
1723 if (i == msg_head_sz) {
1724 /* malformed message */
1725 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1726 return -1;
1727 }
1728 end = msg_head + msg_head_sz;
1729 cur = &msg_head[2];
1730 *msg_len = intdecode(&cur, end);
1731 if (!cur) {
1732 /* malformed message */
1733 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1734 return -1;
1735 }
1736 }
1737
1738 /* Read message content */
1739 if (*msg_len) {
1740 if (*msg_len > trash.size) {
1741 /* Status code is not success, abort */
1742 appctx->st0 = PEER_SESS_ST_ERRSIZE;
1743 return -1;
1744 }
1745
1746 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
1747 if (reql <= 0) /* closed */
1748 goto incomplete;
1749 *totl += reql;
1750 }
1751
1752 return 1;
1753
1754 incomplete:
1755 if (reql < 0) {
1756 /* there was an error */
1757 appctx->st0 = PEER_SESS_ST_END;
1758 return -1;
1759 }
1760
1761 return 0;
1762}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001763
1764/*
1765 * Treat the awaited message with <msg_head> as header.*
1766 * Return 1 if succeeded, 0 if not.
1767 */
1768static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
1769 char **msg_cur, char *msg_end, int msg_len, int totl)
1770{
1771 struct stream_interface *si = appctx->owner;
1772 struct stream *s = si_strm(si);
1773 struct peers *peers = strm_fe(s)->parent;
1774
1775 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
1776 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
1777 struct shared_table *st;
1778 /* Reset message: remote need resync */
1779
1780 /* prepare tables fot a global push */
1781 for (st = peer->tables; st; st = st->next) {
1782 st->teaching_origin = st->last_pushed = st->table->update;
1783 st->flags = 0;
1784 }
1785
1786 /* reset teaching flags to 0 */
1787 peer->flags &= PEER_TEACH_RESET;
1788
1789 /* flag to start to teach lesson */
1790 peer->flags |= PEER_F_TEACH_PROCESS;
1791 }
1792 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
1793 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1794 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1795 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1796 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
1797 }
1798 peer->confirm++;
1799 }
1800 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
1801 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1802 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1803 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1804
1805 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001806 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001807 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
1808 }
1809 peer->confirm++;
1810 }
1811 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
1812 struct shared_table *st;
1813
1814 /* If stopping state */
1815 if (stopping) {
1816 /* Close session, push resync no more needed */
1817 peer->flags |= PEER_F_TEACH_COMPLETE;
1818 appctx->st0 = PEER_SESS_ST_END;
1819 return 0;
1820 }
1821 for (st = peer->tables; st; st = st->next) {
1822 st->update = st->last_pushed = st->teaching_origin;
1823 st->flags = 0;
1824 }
1825
1826 /* reset teaching flags to 0 */
1827 peer->flags &= PEER_TEACH_RESET;
1828 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001829 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001830 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01001831 peer->rx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001832 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001833 }
1834 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
1835 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
1836 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
1837 return 0;
1838 }
1839 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
1840 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
1841 return 0;
1842 }
1843 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
1844 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
1845 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
1846 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
1847 int update, expire;
1848
1849 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
1850 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
1851 if (!peer_treat_updatemsg(appctx, peer, update, expire,
1852 msg_cur, msg_end, msg_len, totl))
1853 return 0;
1854
1855 }
1856 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
1857 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
1858 return 0;
1859 }
1860 }
1861 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
1862 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1863 return 0;
1864 }
1865
1866 return 1;
1867}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001868
1869
1870/*
1871 * Send any message to <peer> peer.
1872 * Returns 1 if succeeded, or -1 or 0 if failed.
1873 * -1 means an internal error occured, 0 is for a peer protocol error leading
1874 * to a peer state change (from the peer I/O handler point of view).
1875 */
1876static inline int peer_send_msgs(struct appctx *appctx, struct peer *peer)
1877{
1878 int repl;
1879 struct stream_interface *si = appctx->owner;
1880 struct stream *s = si_strm(si);
1881 struct peers *peers = strm_fe(s)->parent;
1882
1883 /* Need to request a resync */
1884 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
1885 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
1886 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
1887
1888 repl = peer_send_resync_reqmsg(appctx);
1889 if (repl <= 0)
1890 return repl;
1891
1892 peers->flags |= PEERS_F_RESYNC_PROCESS;
1893 }
1894
1895 /* Nothing to read, now we start to write */
1896 if (peer->tables) {
1897 struct shared_table *st;
1898 struct shared_table *last_local_table;
1899
1900 last_local_table = peer->last_local_table;
1901 if (!last_local_table)
1902 last_local_table = peer->tables;
1903 st = last_local_table->next;
1904
1905 while (1) {
1906 if (!st)
1907 st = peer->tables;
1908
1909 /* It remains some updates to ack */
1910 if (st->last_get != st->last_acked) {
1911 repl = peer_send_ackmsg(st, appctx);
1912 if (repl <= 0)
1913 return repl;
1914
1915 st->last_acked = st->last_get;
1916 }
1917
1918 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
1919 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1920 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
1921 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
1922
1923 repl = peer_send_teach_process_msgs(appctx, peer, st);
1924 if (repl <= 0) {
1925 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1926 return repl;
1927 }
1928 }
1929 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1930 }
1931 else {
1932 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
1933 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
1934 if (repl <= 0)
1935 return repl;
1936 }
1937
1938 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
1939 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
1940 if (repl <= 0)
1941 return repl;
1942 }
1943 }
1944
1945 if (st == last_local_table)
1946 break;
1947 st = st->next;
1948 }
1949 }
1950
1951 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
1952 repl = peer_send_resync_finishedmsg(appctx, peer);
1953 if (repl <= 0)
1954 return repl;
1955
1956 /* flag finished message sent */
1957 peer->flags |= PEER_F_TEACH_FINISHED;
1958 }
1959
1960 /* Confirm finished or partial messages */
1961 while (peer->confirm) {
1962 repl = peer_send_resync_confirmsg(appctx);
1963 if (repl <= 0)
1964 return repl;
1965
1966 peer->confirm--;
1967 }
1968
1969 return 1;
1970}
1971
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001972/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01001973 * Read and parse a first line of a "hello" peer protocol message.
1974 * Returns 0 if could not read a line, -1 if there was a read error or
1975 * the line is malformed, 1 if succeeded.
1976 */
1977static inline int peer_getline_version(struct appctx *appctx,
1978 unsigned int *maj_ver, unsigned int *min_ver)
1979{
1980 int reql;
1981
1982 reql = peer_getline(appctx);
1983 if (!reql)
1984 return 0;
1985
1986 if (reql < 0)
1987 return -1;
1988
1989 /* test protocol */
1990 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
1991 appctx->st0 = PEER_SESS_ST_EXIT;
1992 appctx->st1 = PEER_SESS_SC_ERRPROTO;
1993 return -1;
1994 }
1995 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
1996 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
1997 appctx->st0 = PEER_SESS_ST_EXIT;
1998 appctx->st1 = PEER_SESS_SC_ERRVERSION;
1999 return -1;
2000 }
2001
2002 return 1;
2003}
2004
2005/*
2006 * Read and parse a second line of a "hello" peer protocol message.
2007 * Returns 0 if could not read a line, -1 if there was a read error or
2008 * the line is malformed, 1 if succeeded.
2009 */
2010static inline int peer_getline_host(struct appctx *appctx)
2011{
2012 int reql;
2013
2014 reql = peer_getline(appctx);
2015 if (!reql)
2016 return 0;
2017
2018 if (reql < 0)
2019 return -1;
2020
2021 /* test hostname match */
2022 if (strcmp(localpeer, trash.area) != 0) {
2023 appctx->st0 = PEER_SESS_ST_EXIT;
2024 appctx->st1 = PEER_SESS_SC_ERRHOST;
2025 return -1;
2026 }
2027
2028 return 1;
2029}
2030
2031/*
2032 * Read and parse a last line of a "hello" peer protocol message.
2033 * Returns 0 if could not read a character, -1 if there was a read error or
2034 * the line is malformed, 1 if succeeded.
2035 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2036 */
2037static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2038{
2039 char *p;
2040 int reql;
2041 struct peer *peer;
2042 struct stream_interface *si = appctx->owner;
2043 struct stream *s = si_strm(si);
2044 struct peers *peers = strm_fe(s)->parent;
2045
2046 reql = peer_getline(appctx);
2047 if (!reql)
2048 return 0;
2049
2050 if (reql < 0)
2051 return -1;
2052
2053 /* parse line "<peer name> <pid> <relative_pid>" */
2054 p = strchr(trash.area, ' ');
2055 if (!p) {
2056 appctx->st0 = PEER_SESS_ST_EXIT;
2057 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2058 return -1;
2059 }
2060 *p = 0;
2061
2062 /* lookup known peer */
2063 for (peer = peers->remote; peer; peer = peer->next) {
2064 if (strcmp(peer->id, trash.area) == 0)
2065 break;
2066 }
2067
2068 /* if unknown peer */
2069 if (!peer) {
2070 appctx->st0 = PEER_SESS_ST_EXIT;
2071 appctx->st1 = PEER_SESS_SC_ERRPEER;
2072 return -1;
2073 }
2074 *curpeer = peer;
2075
2076 return 1;
2077}
2078
2079/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002080 * Init <peer> peer after having accepted it at peer protocol level.
2081 */
2082static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2083{
2084 struct shared_table *st;
2085
2086 /* Register status code */
2087 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
2088
2089 /* Awake main task */
2090 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2091
2092 /* Init confirm counter */
2093 peer->confirm = 0;
2094
2095 /* Init cursors */
2096 for (st = peer->tables; st ; st = st->next) {
2097 st->last_get = st->last_acked = 0;
2098 st->teaching_origin = st->last_pushed = st->update;
2099 }
2100
2101 /* reset teaching and learning flags to 0 */
2102 peer->flags &= PEER_TEACH_RESET;
2103 peer->flags &= PEER_LEARN_RESET;
2104
2105 /* if current peer is local */
2106 if (peer->local) {
2107 /* if current host need resyncfrom local and no process assined */
2108 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2109 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2110 /* assign local peer for a lesson, consider lesson already requested */
2111 peer->flags |= PEER_F_LEARN_ASSIGN;
2112 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2113 }
2114
2115 }
2116 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2117 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2118 /* assign peer for a lesson */
2119 peer->flags |= PEER_F_LEARN_ASSIGN;
2120 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2121 }
2122}
2123
2124/*
2125 * Init <peer> peer after having connected it at peer protocol level.
2126 */
2127static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2128{
2129 struct shared_table *st;
2130
2131 /* Init cursors */
2132 for (st = peer->tables; st ; st = st->next) {
2133 st->last_get = st->last_acked = 0;
2134 st->teaching_origin = st->last_pushed = st->update;
2135 }
2136
2137 /* Init confirm counter */
2138 peer->confirm = 0;
2139
2140 /* reset teaching and learning flags to 0 */
2141 peer->flags &= PEER_TEACH_RESET;
2142 peer->flags &= PEER_LEARN_RESET;
2143
2144 /* If current peer is local */
2145 if (peer->local) {
2146 /* flag to start to teach lesson */
2147 peer->flags |= PEER_F_TEACH_PROCESS;
2148 }
2149 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2150 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2151 /* If peer is remote and resync from remote is needed,
2152 and no peer currently assigned */
2153
2154 /* assign peer for a lesson */
2155 peer->flags |= PEER_F_LEARN_ASSIGN;
2156 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2157 }
2158}
2159
2160/*
Emeric Brun2b920a12010-09-23 18:30:22 +02002161 * IO Handler to handle message exchance with a peer
2162 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002163static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002164{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002165 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002166 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002167 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002168 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002169 int reql = 0;
2170 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002171 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002172 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002173
Joseph Herlant82b2f542018-11-15 12:19:14 -08002174 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002175 if (si_ic(si)->buf.size == 0) {
2176 si_rx_room_blk(si);
2177 goto out;
2178 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002179
Emeric Brun2b920a12010-09-23 18:30:22 +02002180 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002181 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002182switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002183 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002184 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002185 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002186 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002187 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002188 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002189 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002190 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002191 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002192 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2193 if (reql <= 0) {
2194 if (!reql)
2195 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002196 goto switchstate;
2197 }
2198
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002199 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002200 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002201 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002202 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002203 reql = peer_getline_host(appctx);
2204 if (reql <= 0) {
2205 if (!reql)
2206 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002207 goto switchstate;
2208 }
2209
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002210 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002211 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002212 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002213 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002214 reql = peer_getline_last(appctx, &curpeer);
2215 if (reql <= 0) {
2216 if (!reql)
2217 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002218 goto switchstate;
2219 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002220
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002221 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002222 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002223 if (curpeer->local) {
2224 /* Local connection, reply a retry */
2225 appctx->st0 = PEER_SESS_ST_EXIT;
2226 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2227 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002228 }
Emeric Brun80527f52017-06-19 17:46:37 +02002229
2230 /* we're killing a connection, we must apply a random delay before
2231 * retrying otherwise the other end will do the same and we can loop
2232 * for a while.
2233 */
2234 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002235 peer_session_forceshutdown(curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002236 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002237 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2238 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2239 curpeer->flags |= PEER_F_DWNGRD;
2240 }
2241 else {
2242 curpeer->flags &= ~PEER_F_DWNGRD;
2243 }
2244 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002245 curpeer->appctx = appctx;
2246 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002247 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002248 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002249 /* fall through */
2250 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002251 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002252 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002253 if (!curpeer) {
2254 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002255 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002256 if (curpeer->appctx != appctx) {
2257 appctx->st0 = PEER_SESS_ST_END;
2258 goto switchstate;
2259 }
2260 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002261
2262 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002263 if (repl <= 0) {
2264 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002265 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002266 goto switchstate;
2267 }
2268
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002269 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002270
Emeric Brun2b920a12010-09-23 18:30:22 +02002271 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002272 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002273 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002274 goto switchstate;
2275 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002276 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002277 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002278 if (!curpeer) {
2279 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002280 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002281 if (curpeer->appctx != appctx) {
2282 appctx->st0 = PEER_SESS_ST_END;
2283 goto switchstate;
2284 }
2285 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002286
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002287 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002288 if (repl <= 0) {
2289 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002290 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002291 goto switchstate;
2292 }
2293
2294 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002295 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002296 /* fall through */
2297 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002298 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002299 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002300 if (!curpeer) {
2301 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002302 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002303 if (curpeer->appctx != appctx) {
2304 appctx->st0 = PEER_SESS_ST_END;
2305 goto switchstate;
2306 }
2307 }
2308
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002309 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002310 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002311
Frédéric Lécaillece025572019-01-21 13:38:06 +01002312 reql = peer_getline(appctx);
2313 if (!reql)
2314 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002315
Frédéric Lécaillece025572019-01-21 13:38:06 +01002316 if (reql < 0)
2317 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002318
2319 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002320 curpeer->statuscode = atoi(trash.area);
Emeric Brun2b920a12010-09-23 18:30:22 +02002321
2322 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002323 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002324
2325 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002326 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002327 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002328 }
2329 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002330 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2331 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002332 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002333 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002334 goto switchstate;
2335 }
Olivier Houcharded879892019-03-08 18:53:43 +01002336 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002337 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002338 /* fall through */
2339 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002340 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002341 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002342 char *msg_cur = trash.area;
2343 char *msg_end = trash.area;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002344 unsigned char msg_head[7];
Emeric Brun2b920a12010-09-23 18:30:22 +02002345 int totl = 0;
2346
Willy Tarreau2d372c22018-11-05 17:12:27 +01002347 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002348 if (!curpeer) {
2349 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002350 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002351 if (curpeer->appctx != appctx) {
2352 appctx->st0 = PEER_SESS_ST_END;
2353 goto switchstate;
2354 }
2355 }
2356
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002357 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2358 if (reql <= 0) {
2359 if (reql == -1)
2360 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002361 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002362 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002363
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002364 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002365 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002366 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002367
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002368 curpeer->flags |= PEER_F_ALIVE;
2369
Emeric Brun2b920a12010-09-23 18:30:22 +02002370 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002371 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002372 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002373 goto switchstate;
2374
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002375send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002376 if (curpeer->flags & PEER_F_HEARTBEAT) {
2377 curpeer->flags &= ~PEER_F_HEARTBEAT;
2378 repl = peer_send_heartbeatmsg(appctx);
2379 if (repl <= 0) {
2380 if (repl == -1)
2381 goto out;
2382 goto switchstate;
2383 }
Frédéric Lécaille33cab3c2019-11-06 11:51:26 +01002384 curpeer->tx_hbt++;
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002385 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002386 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002387 repl = peer_send_msgs(appctx, curpeer);
2388 if (repl <= 0) {
2389 if (repl == -1)
2390 goto out;
2391 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002392 }
2393
Emeric Brun2b920a12010-09-23 18:30:22 +02002394 /* noting more to do */
2395 goto out;
2396 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002397 case PEER_SESS_ST_EXIT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002398 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002399 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002400 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002401 if (peer_send_status_errormsg(appctx) == -1)
2402 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002403 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002404 goto switchstate;
2405 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002406 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002407 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002408 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002409 if (peer_send_error_size_limitmsg(appctx) == -1)
2410 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002411 appctx->st0 = PEER_SESS_ST_END;
2412 goto switchstate;
2413 }
2414 case PEER_SESS_ST_ERRPROTO: {
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002415 if (curpeer)
2416 curpeer->proto_err++;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002417 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002418 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002419 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002420 if (peer_send_error_protomsg(appctx) == -1)
2421 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002422 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002423 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002424 /* fall through */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002425 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002426 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002427 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002428 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002429 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002430 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002431 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002432 curpeer = NULL;
2433 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002434 si_shutw(si);
2435 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002436 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002437 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002438 }
2439 }
2440 }
2441out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002442 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002443
2444 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002445 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002446 return;
2447}
2448
Willy Tarreau30576452015-04-13 13:50:30 +02002449static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002450 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002451 .name = "<PEER>", /* used for logging */
2452 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002453 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002454};
Emeric Brun2b920a12010-09-23 18:30:22 +02002455
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002456
Emeric Brun2b920a12010-09-23 18:30:22 +02002457/*
2458 * Use this function to force a close of a peer session
2459 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002460static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002461{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002462 struct appctx *appctx = peer->appctx;
2463
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002464 /* Note that the peer sessions which have just been created
2465 * (->st0 == PEER_SESS_ST_CONNECT) must not
2466 * be shutdown, if not, the TCP session will never be closed
2467 * and stay in CLOSE_WAIT state after having been closed by
2468 * the remote side.
2469 */
2470 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002471 return;
2472
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002473 if (appctx->applet != &peer_applet)
2474 return;
2475
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002476 __peer_session_deinit(peer);
2477
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002478 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002479 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002480}
2481
Willy Tarreau91d96282015-03-13 15:47:26 +01002482/* Pre-configures a peers frontend to accept incoming connections */
2483void peers_setup_frontend(struct proxy *fe)
2484{
2485 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002486 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreau91d96282015-03-13 15:47:26 +01002487 fe->maxconn = 0;
2488 fe->conn_retries = CONN_RETRIES;
2489 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002490 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002491 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002492 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002493 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002494}
2495
Emeric Brun2b920a12010-09-23 18:30:22 +02002496/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002497 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002498 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002499static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002500{
Willy Tarreau04b92862017-09-15 11:01:04 +02002501 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002502 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002503 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002504 struct stream *s;
Emeric Brun2b920a12010-09-23 18:30:22 +02002505
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002506 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002507 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Emeric Brunb3971ab2015-05-12 18:49:09 +02002508 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002509 s = NULL;
2510
Emeric Brun1138fd02017-06-19 12:38:55 +02002511 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002512 if (!appctx)
2513 goto out_close;
2514
2515 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002516 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002517
Willy Tarreau04b92862017-09-15 11:01:04 +02002518 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002519 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002520 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002521 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002522 }
2523
Willy Tarreau87787ac2017-08-28 16:22:54 +02002524 if ((s = stream_new(sess, &appctx->obj_type)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002525 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002526 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002527 }
2528
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002529 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002530 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002531 appctx_wakeup(appctx);
2532
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002533 /* initiate an outgoing connection */
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002534 s->target = peer_session_target(peer, s);
2535 if (!sockaddr_alloc(&s->target_addr))
2536 goto out_free_strm;
2537 *s->target_addr = peer->addr;
Willy Tarreau02efeda2019-07-18 17:21:24 +02002538 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Willy Tarreaudbd02672017-12-06 17:39:53 +01002539 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002540
Emeric Brun2b920a12010-09-23 18:30:22 +02002541 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002542 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002543
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002544 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002545
Emeric Brunb3971ab2015-05-12 18:49:09 +02002546 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002547 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002548 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002549 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002550
2551 /* Error unrolling */
Willy Tarreau15b5e142015-04-04 14:38:25 +02002552 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002553 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002554 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002555 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002556 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002557 out_free_appctx:
2558 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002559 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002560 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002561}
2562
2563/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002564 * Task processing function to manage re-connect, peer session
2565 * tasks wakeup on local update and heartbeat.
Emeric Brun2b920a12010-09-23 18:30:22 +02002566 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02002567static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002568{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002569 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002570 struct peer *ps;
2571 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002572
2573 task->expire = TICK_ETERNITY;
2574
Emeric Brunb3971ab2015-05-12 18:49:09 +02002575 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002576 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002577 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002578 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002579 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002580 return NULL;
2581 }
2582
Emeric Brun80527f52017-06-19 17:46:37 +02002583 /* Acquire lock for all peers of the section */
2584 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002585 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002586
Emeric Brun2b920a12010-09-23 18:30:22 +02002587 if (!stopping) {
2588 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002589
2590 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2591 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2592 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002593 /* Resync from local peer needed
2594 no peer was assigned for the lesson
2595 and no old local peer found
2596 or resync timeout expire */
2597
2598 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002599 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002600
2601 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002602 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002603 }
2604
2605 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002606 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002607 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002608 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002609 if (!ps->appctx) {
2610 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002611 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002612 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002613 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002614 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002615 tick_is_expired(ps->reconnect, now_ms))) {
2616 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002617 * or previous peer connection established with success
2618 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002619 * and reconnection timer is expired */
2620
2621 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002622 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002623 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002624 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002625 /* If previous session failed during connection
2626 * but reconnection timer is not expired */
2627
2628 /* reschedule task for reconnect */
2629 task->expire = tick_first(task->expire, ps->reconnect);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002630 ps->new_conn++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002631 }
2632 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002633 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002634 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002635 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002636 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2637 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002638 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2639 /* Resync from a remote is needed
2640 * and no peer was assigned for lesson
2641 * and current peer may be up2date */
2642
2643 /* assign peer for the lesson */
2644 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002645 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002646
Willy Tarreau9df94c22016-10-31 18:42:52 +01002647 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002648 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002649 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002650 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002651 int update_to_push = 0;
2652
Emeric Brunb3971ab2015-05-12 18:49:09 +02002653 /* Awake session if there is data to push */
2654 for (st = ps->tables; st ; st = st->next) {
2655 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002656 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002657 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002658 /* There is no need to send a heartbeat message
2659 * when some updates must be pushed. The remote
2660 * peer will consider <ps> peer as alive when it will
2661 * receive these updates.
2662 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002663 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002664 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002665 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002666 /* We are going to send updates, let's ensure we will
2667 * come back to send heartbeat messages or to reconnect.
2668 */
2669 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002670 appctx_wakeup(ps->appctx);
2671 break;
2672 }
2673 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002674 /* When there are updates to send we do not reconnect
2675 * and do not send heartbeat message either.
2676 */
2677 if (!update_to_push) {
2678 if (tick_is_expired(ps->reconnect, now_ms)) {
2679 if (ps->flags & PEER_F_ALIVE) {
2680 /* This peer was alive during a 'reconnect' period.
2681 * Flag it as not alive again for the next period.
2682 */
2683 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002684 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002685 }
2686 else {
2687 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002688 peer_session_forceshutdown(ps);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01002689 ps->no_hbt++;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002690 }
2691 }
2692 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2693 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
2694 ps->flags |= PEER_F_HEARTBEAT;
2695 appctx_wakeup(ps->appctx);
2696 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01002697 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002698 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002699 }
2700 /* else do nothing */
2701 } /* SUCCESSCODE */
2702 } /* !ps->peer->local */
2703 } /* for */
2704
2705 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002706 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2707 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2708 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002709 /* Resync from remote peer needed
2710 * no peer was assigned for the lesson
2711 * and resync timeout expire */
2712
2713 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002714 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002715 }
2716
Emeric Brunb3971ab2015-05-12 18:49:09 +02002717 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002718 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02002719 /* reschedule task to resync timeout if not expired, to ended resync if needed */
2720 if (!tick_is_expired(peers->resync_timeout, now_ms))
2721 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02002722 }
2723 } /* !stopping */
2724 else {
2725 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01002726 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08002727 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002728 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002729 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01002730 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002731 peers->flags |= PEERS_F_DONOTSTOP;
2732 ps = peers->local;
2733 for (st = ps->tables; st ; st = st->next)
2734 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002735 }
2736
2737 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002738 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02002739 /* we're killing a connection, we must apply a random delay before
2740 * retrying otherwise the other end will do the same and we can loop
2741 * for a while.
2742 */
2743 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01002744 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002745 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002746 }
2747 }
2748 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002749
Emeric Brunb3971ab2015-05-12 18:49:09 +02002750 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02002751 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002752 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002753 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002754 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002755 peers->flags &= ~PEERS_F_DONOTSTOP;
2756 for (st = ps->tables; st ; st = st->next)
2757 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002758 }
2759 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01002760 else if (!ps->appctx) {
2761 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002762 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002763 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
2764 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
2765 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002766 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002767 * or previous peer connection was successfully established
2768 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02002769 * or during previous connect, peer replies a try again statuscode */
2770
2771 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002772 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002773 }
2774 else {
2775 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002776 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002777 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002778 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002779 peers->flags &= ~PEERS_F_DONOTSTOP;
2780 for (st = ps->tables; st ; st = st->next)
2781 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002782 }
2783 }
2784 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002785 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002786 /* current peer connection is active and established
2787 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002788 for (st = ps->tables; st ; st = st->next) {
2789 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002790 appctx_wakeup(ps->appctx);
2791 break;
2792 }
2793 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002794 }
2795 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02002796
2797 /* Release lock for all peers of the section */
2798 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002799 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002800
Emeric Brun2b920a12010-09-23 18:30:22 +02002801 /* Wakeup for re-connect */
2802 return task;
2803}
2804
Emeric Brunb3971ab2015-05-12 18:49:09 +02002805
Emeric Brun2b920a12010-09-23 18:30:22 +02002806/*
Willy Tarreaud9443442018-10-15 11:18:03 +02002807 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02002808 */
Willy Tarreaud9443442018-10-15 11:18:03 +02002809int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02002810{
Emeric Brun2b920a12010-09-23 18:30:22 +02002811 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02002812
Emeric Brun2b920a12010-09-23 18:30:22 +02002813 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002814 peers->peers_fe->maxconn += 3;
2815 }
2816
Emeric Brunc60def82017-09-27 14:59:38 +02002817 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02002818 if (!peers->sync_task)
2819 return 0;
2820
Emeric Brunb3971ab2015-05-12 18:49:09 +02002821 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002822 peers->sync_task->context = (void *)peers;
2823 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
2824 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02002825 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002826}
2827
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002828/*
2829 * Allocate a cache a dictionary entries used upon transmission.
2830 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002831static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002832{
2833 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002834 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002835
2836 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002837 entries = calloc(max_entries, sizeof *entries);
2838 if (!d || !entries)
2839 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002840
2841 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002842 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002843 d->cached_entries = EB_ROOT_UNIQUE;
2844 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002845
2846 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002847
2848 err:
2849 free(d);
2850 free(entries);
2851 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002852}
2853
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002854static void free_dcache_tx(struct dcache_tx *dc)
2855{
2856 free(dc->entries);
2857 dc->entries = NULL;
2858 free(dc);
2859}
2860
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002861/*
2862 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
2863 * as maximum of entries.
2864 * Return the dictionay cache if succeeded, NULL if not.
2865 * Must be deallocated calling free_dcache().
2866 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002867static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002868{
2869 struct dcache_tx *dc_tx;
2870 struct dcache *dc;
2871 struct dcache_rx *dc_rx;
2872
2873 dc = calloc(1, sizeof *dc);
2874 dc_tx = new_dcache_tx(max_entries);
2875 dc_rx = calloc(max_entries, sizeof *dc_rx);
2876 if (!dc || !dc_tx || !dc_rx)
2877 goto err;
2878
2879 dc->tx = dc_tx;
2880 dc->rx = dc_rx;
2881 dc->max_entries = max_entries;
2882
2883 return dc;
2884
2885 err:
2886 free(dc);
2887 free(dc_tx);
2888 free(dc_rx);
2889 return NULL;
2890}
2891
2892/*
2893 * Deallocate a cache of dictionary entries.
2894 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002895static inline void free_dcache(struct dcache *dc)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002896{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002897 free_dcache_tx(dc->tx);
2898 dc->tx = NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002899 free(dc->rx); dc->rx = NULL;
2900 free(dc);
2901}
2902
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002903
2904/*
2905 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
2906 * entries used upon transmission.
2907 * Return the entry if found, NULL if not.
2908 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002909static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
2910 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002911{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002912 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002913}
2914
2915/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002916 * Flush <dc> cache.
2917 * Always succeeds.
2918 */
2919static inline void flush_dcache(struct peer *peer)
2920{
2921 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002922 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002923
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002924 for (i = 0; i < dc->max_entries; i++)
2925 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002926
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002927 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002928}
2929
2930/*
2931 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
2932 * with information provided by <i> dictionary cache entry (especially the value
2933 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002934 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002935 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002936static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002937{
2938 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002939 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002940
2941 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002942
2943 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
2944 o = dc_tx->prev_lookup;
2945 } else {
2946 o = dcache_tx_lookup_value(dc_tx, i);
2947 if (o) {
2948 /* Save it */
2949 dc_tx->prev_lookup = o;
2950 }
2951 }
2952
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002953 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002954 /* Copy the ID. */
2955 i->id = o - dc->tx->entries;
2956 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002957 }
2958
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002959 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002960 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002961
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002962 ebpt_delete(o);
2963 o->key = i->entry.key;
2964 ebpt_insert(&dc_tx->cached_entries, o);
2965 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002966
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002967 /* Update the index for the next entry to put in cache */
2968 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002969
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002970 return o;
2971}
Emeric Brunb3971ab2015-05-12 18:49:09 +02002972
2973/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002974 * Allocate a dictionary cache for each peer of <peers> section.
2975 * Return 1 if succeeded, 0 if not.
2976 */
2977int peers_alloc_dcache(struct peers *peers)
2978{
2979 struct peer *p;
2980
2981 for (p = peers->remote; p; p = p->next) {
2982 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
2983 if (!p->dcache)
2984 return 0;
2985 }
2986
2987 return 1;
2988}
2989
2990/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02002991 * Function used to register a table for sync on a group of peers
2992 *
2993 */
2994void peers_register_table(struct peers *peers, struct stktable *table)
2995{
2996 struct shared_table *st;
2997 struct peer * curpeer;
2998 int id = 0;
2999
3000 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003001 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003002 st->table = table;
3003 st->next = curpeer->tables;
3004 if (curpeer->tables)
3005 id = curpeer->tables->local_id;
3006 st->local_id = id + 1;
3007
3008 curpeer->tables = st;
3009 }
3010
3011 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003012}
3013
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003014/*
3015 * Parse the "show peers" command arguments.
3016 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3017 * error message.
3018 */
3019static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3020{
3021 appctx->ctx.cfgpeers.target = NULL;
3022
3023 if (*args[2]) {
3024 struct peers *p;
3025
3026 for (p = cfg_peers; p; p = p->next) {
3027 if (!strcmp(p->id, args[2])) {
3028 appctx->ctx.cfgpeers.target = p;
3029 break;
3030 }
3031 }
3032
Willy Tarreau9d008692019-08-09 11:21:01 +02003033 if (!p)
3034 return cli_err(appctx, "No such peers\n");
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003035 }
3036
3037 return 0;
3038}
3039
3040/*
3041 * This function dumps the peer state information of <peers> "peers" section.
3042 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3043 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3044 */
3045static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3046{
3047 struct tm tm;
3048
3049 get_localtime(peers->last_change, &tm);
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003050 chunk_appendf(msg, "%p: [%02d/%s/%04d:%02d:%02d:%02d] id=%s state=%d flags=0x%x resync_timeout=%s task_calls=%u\n",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003051 peers,
3052 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3053 tm.tm_hour, tm.tm_min, tm.tm_sec,
3054 peers->id, peers->state, peers->flags,
3055 peers->resync_timeout ?
3056 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3057 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003058 TICKS_TO_MS(1000)) : "<NEVER>",
3059 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003060
3061 if (ci_putchk(si_ic(si), msg) == -1) {
3062 si_rx_room_blk(si);
3063 return 0;
3064 }
3065
3066 return 1;
3067}
3068
3069/*
3070 * This function dumps <peer> state information.
3071 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3072 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3073 */
3074static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3075{
3076 struct connection *conn;
3077 char pn[INET6_ADDRSTRLEN];
3078 struct stream_interface *peer_si;
3079 struct stream *peer_s;
3080 struct appctx *appctx;
3081 struct shared_table *st;
3082
3083 addr_to_str(&peer->addr, pn, sizeof pn);
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003084 chunk_appendf(msg, " %p: id=%s(%s) addr=%s:%d status=%s reconnect=%s confirm=%u tx_hbt=%u rx_hbt=%u no_hbt=%u new_conn=%u proto_err=%u\n",
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003085 peer, peer->id,
3086 peer->local ? "local" : "remote",
3087 pn, get_host_port(&peer->addr),
3088 statuscode_str(peer->statuscode),
3089 peer->reconnect ?
3090 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3091 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
3092 TICKS_TO_MS(1000)) : "<NEVER>",
Frédéric Lécailleec1c10b2019-11-07 15:22:33 +01003093 peer->confirm, peer->tx_hbt, peer->rx_hbt,
3094 peer->no_hbt, peer->new_conn, peer->proto_err);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003095
3096 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3097
3098 appctx = peer->appctx;
3099 if (!appctx)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003100 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003101
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003102 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3103 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003104
3105 peer_si = peer->appctx->owner;
3106 if (!peer_si)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003107 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003108
3109 peer_s = si_strm(peer_si);
3110 if (!peer_s)
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003111 goto table_info;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003112
3113 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3114
3115 conn = objt_conn(strm_orig(peer_s));
3116 if (conn)
3117 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3118
Willy Tarreau3ca14902019-07-17 14:53:15 +02003119 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 +02003120 case AF_INET:
3121 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003122 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(conn->src));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003123 break;
3124 case AF_UNIX:
3125 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3126 break;
3127 }
3128
Willy Tarreau3ca14902019-07-17 14:53:15 +02003129 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 +02003130 case AF_INET:
3131 case AF_INET6:
Willy Tarreau3ca14902019-07-17 14:53:15 +02003132 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(conn->dst));
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003133 break;
3134 case AF_UNIX:
3135 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3136 break;
3137 }
3138
Frédéric Lécaille470502b2019-11-06 10:41:03 +01003139 table_info:
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003140 if (peer->remote_table)
3141 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3142 peer->remote_table,
3143 peer->remote_table->table->id,
3144 peer->remote_table->local_id,
3145 peer->remote_table->remote_id);
3146
3147 if (peer->last_local_table)
3148 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3149 peer->last_local_table,
3150 peer->last_local_table->table->id,
3151 peer->last_local_table->local_id,
3152 peer->last_local_table->remote_id);
3153
3154 if (peer->tables) {
3155 chunk_appendf(&trash, "\n shared tables:");
3156 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003157 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003158 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003159 struct dcache *dcache;
3160
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003161 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003162 dcache = peer->dcache;
3163
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003164 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3165 "flags=0x%x remote_data=0x%llx",
3166 st, st->local_id, st->remote_id,
3167 st->flags, (unsigned long long)st->remote_data);
3168 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3169 " teaching_origin=%u update=%u",
3170 st->last_acked, st->last_pushed, st->last_get,
3171 st->teaching_origin, st->update);
3172 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3173 " commitupdate=%u syncing=%u",
3174 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003175 chunk_appendf(&trash, "\n TX dictionary cache:");
3176 count = 0;
3177 for (i = 0; i < dcache->max_entries; i++) {
3178 struct ebpt_node *node;
3179 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003180
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003181 node = &dcache->tx->entries[i];
3182 if (!node->key)
3183 break;
3184
3185 if (!count++)
3186 chunk_appendf(&trash, "\n ");
3187 de = node->key;
3188 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3189 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003190 }
3191 chunk_appendf(&trash, "\n RX dictionary cache:");
3192 count = 0;
3193 for (i = 0; i < dcache->max_entries; i++) {
3194 if (!count++)
3195 chunk_appendf(&trash, "\n ");
3196 chunk_appendf(&trash, " %3u -> %s", i,
3197 dcache->rx[i].de ?
3198 (char *)dcache->rx[i].de->value.key : "-");
3199 count &= 0x3;
3200 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003201 }
3202 }
3203
3204 end:
3205 chunk_appendf(&trash, "\n");
3206 if (ci_putchk(si_ic(si), msg) == -1) {
3207 si_rx_room_blk(si);
3208 return 0;
3209 }
3210
3211 return 1;
3212}
3213
3214/*
3215 * This function dumps all the peers of "peers" section.
3216 * Returns 0 if the output buffer is full and needs to be called
3217 * again, non-zero if not. It proceeds in an isolated thread, so
3218 * there is no thread safety issue here.
3219 */
3220static int cli_io_handler_show_peers(struct appctx *appctx)
3221{
3222 int show_all;
3223 int ret = 0, first_peers = 1;
3224 struct stream_interface *si = appctx->owner;
3225
3226 thread_isolate();
3227
3228 show_all = !appctx->ctx.cfgpeers.target;
3229
3230 chunk_reset(&trash);
3231
3232 while (appctx->st2 != STAT_ST_FIN) {
3233 switch (appctx->st2) {
3234 case STAT_ST_INIT:
3235 if (show_all)
3236 appctx->ctx.cfgpeers.peers = cfg_peers;
3237 else
3238 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3239
3240 appctx->st2 = STAT_ST_LIST;
3241 /* fall through */
3242
3243 case STAT_ST_LIST:
3244 if (!appctx->ctx.cfgpeers.peers) {
3245 /* No more peers list. */
3246 appctx->st2 = STAT_ST_END;
3247 }
3248 else {
3249 if (!first_peers)
3250 chunk_appendf(&trash, "\n");
3251 else
3252 first_peers = 0;
3253 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3254 goto out;
3255
3256 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3257 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3258 appctx->st2 = STAT_ST_INFO;
3259 }
3260 break;
3261
3262 case STAT_ST_INFO:
3263 if (!appctx->ctx.cfgpeers.peer) {
3264 /* End of peer list */
3265 if (show_all)
3266 appctx->st2 = STAT_ST_LIST;
3267 else
3268 appctx->st2 = STAT_ST_END;
3269 }
3270 else {
3271 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3272 goto out;
3273
3274 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3275 }
3276 break;
3277
3278 case STAT_ST_END:
3279 appctx->st2 = STAT_ST_FIN;
3280 break;
3281 }
3282 }
3283 ret = 1;
3284 out:
3285 thread_release();
3286 return ret;
3287}
3288
3289/*
3290 * CLI keywords.
3291 */
3292static struct cli_kw_list cli_kws = {{ }, {
3293 { { "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, },
3294 {},
3295}};
3296
3297/* Register cli keywords */
3298INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3299