blob: 10fee312c1efd529ee0da425411ace03daf71db8 [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>
43#include <proto/hdr_idx.h>
Willy Tarreau53a47662017-08-28 10:53:00 +020044#include <proto/mux_pt.h>
Frédéric Lécaille1055e682018-04-26 14:35:21 +020045#include <proto/peers.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020046#include <proto/proxy.h>
Willy Tarreaufeb76402015-04-03 14:10:06 +020047#include <proto/session.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020048#include <proto/stream.h>
Willy Tarreau22ec1ea2014-11-27 20:45:39 +010049#include <proto/signal.h>
50#include <proto/stick_table.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020051#include <proto/stream_interface.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020052#include <proto/task.h>
Emeric Brun2b920a12010-09-23 18:30:22 +020053
54
55/*******************************/
56/* Current peer learning state */
57/*******************************/
58
59/******************************/
Emeric Brunb3971ab2015-05-12 18:49:09 +020060/* Current peers section resync state */
Emeric Brun2b920a12010-09-23 18:30:22 +020061/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010062#define PEERS_F_RESYNC_LOCAL 0x00000001 /* Learn from local finished or no more needed */
63#define PEERS_F_RESYNC_REMOTE 0x00000002 /* Learn from remote finished or no more needed */
64#define PEERS_F_RESYNC_ASSIGN 0x00000004 /* A peer was assigned to learn our lesson */
65#define PEERS_F_RESYNC_PROCESS 0x00000008 /* The assigned peer was requested for resync */
66#define PEERS_F_DONOTSTOP 0x00010000 /* Main table sync task block process during soft stop
67 to push data to new process */
Emeric Brun2b920a12010-09-23 18:30:22 +020068
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010069#define PEERS_RESYNC_STATEMASK (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
70#define PEERS_RESYNC_FROMLOCAL 0x00000000
71#define PEERS_RESYNC_FROMREMOTE PEERS_F_RESYNC_LOCAL
72#define PEERS_RESYNC_FINISHED (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE)
Emeric Brunb3971ab2015-05-12 18:49:09 +020073
74/***********************************/
75/* Current shared table sync state */
76/***********************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010077#define SHTABLE_F_TEACH_STAGE1 0x00000001 /* Teach state 1 complete */
78#define SHTABLE_F_TEACH_STAGE2 0x00000002 /* Teach state 2 complete */
Emeric Brun2b920a12010-09-23 18:30:22 +020079
80/******************************/
81/* Remote peer teaching state */
82/******************************/
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010083#define PEER_F_TEACH_PROCESS 0x00000001 /* Teach a lesson to current peer */
84#define PEER_F_TEACH_FINISHED 0x00000008 /* Teach conclude, (wait for confirm) */
85#define PEER_F_TEACH_COMPLETE 0x00000010 /* All that we know already taught to current peer, used only for a local peer */
86#define PEER_F_LEARN_ASSIGN 0x00000100 /* Current peer was assigned for a lesson */
87#define PEER_F_LEARN_NOTUP2DATE 0x00000200 /* Learn from peer finished but peer is not up to date */
88#define PEER_F_ALIVE 0x20000000 /* Used to flag a peer a alive. */
89#define PEER_F_HEARTBEAT 0x40000000 /* Heartbeat message to send. */
90#define PEER_F_DWNGRD 0x80000000 /* When this flag is enabled, we must downgrade the supported version announced during peer sessions. */
Emeric Brun2b920a12010-09-23 18:30:22 +020091
Frédéric Lécailleaba44a22019-03-26 10:18:07 +010092#define PEER_TEACH_RESET ~(PEER_F_TEACH_PROCESS|PEER_F_TEACH_FINISHED) /* PEER_F_TEACH_COMPLETE should never be reset */
93#define PEER_LEARN_RESET ~(PEER_F_LEARN_ASSIGN|PEER_F_LEARN_NOTUP2DATE)
Emeric Brun2b920a12010-09-23 18:30:22 +020094
Frédéric Lécaille54bff832019-03-26 10:25:20 +010095#define PEER_RESYNC_TIMEOUT 5000 /* 5 seconds */
96#define PEER_RECONNECT_TIMEOUT 5000 /* 5 seconds */
Frédéric Lécaille645635d2019-02-11 17:49:39 +010097#define PEER_HEARTBEAT_TIMEOUT 3000 /* 3 seconds */
98
Emeric Brunb3971ab2015-05-12 18:49:09 +020099/*****************************/
100/* Sync message class */
101/*****************************/
102enum {
103 PEER_MSG_CLASS_CONTROL = 0,
104 PEER_MSG_CLASS_ERROR,
105 PEER_MSG_CLASS_STICKTABLE = 10,
106 PEER_MSG_CLASS_RESERVED = 255,
107};
108
109/*****************************/
110/* control message types */
111/*****************************/
112enum {
113 PEER_MSG_CTRL_RESYNCREQ = 0,
114 PEER_MSG_CTRL_RESYNCFINISHED,
115 PEER_MSG_CTRL_RESYNCPARTIAL,
116 PEER_MSG_CTRL_RESYNCCONFIRM,
Frédéric Lécaille645635d2019-02-11 17:49:39 +0100117 PEER_MSG_CTRL_HEARTBEAT,
Emeric Brunb3971ab2015-05-12 18:49:09 +0200118};
119
120/*****************************/
121/* error message types */
122/*****************************/
123enum {
124 PEER_MSG_ERR_PROTOCOL = 0,
125 PEER_MSG_ERR_SIZELIMIT,
126};
127
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100128/*
129 * Parameters used by functions to build peer protocol messages. */
130struct peer_prep_params {
131 struct {
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100132 struct peer *peer;
133 } hello;
134 struct {
135 unsigned int st1;
136 } error_status;
137 struct {
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100138 struct stksess *stksess;
139 struct shared_table *shared_table;
140 unsigned int updateid;
141 int use_identifier;
142 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200143 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100144 } updt;
145 struct {
146 struct shared_table *shared_table;
147 } swtch;
148 struct {
149 struct shared_table *shared_table;
150 } ack;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100151 struct {
152 unsigned char head[2];
153 } control;
154 struct {
155 unsigned char head[2];
156 } error;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100157};
Emeric Brunb3971ab2015-05-12 18:49:09 +0200158
159/*******************************/
160/* stick table sync mesg types */
161/* Note: ids >= 128 contains */
162/* id message cotains data */
163/*******************************/
Olivier Houchard33992262018-10-16 18:49:26 +0200164#define PEER_MSG_STKT_UPDATE 0x80
165#define PEER_MSG_STKT_INCUPDATE 0x81
166#define PEER_MSG_STKT_DEFINE 0x82
167#define PEER_MSG_STKT_SWITCH 0x83
168#define PEER_MSG_STKT_ACK 0x84
169#define PEER_MSG_STKT_UPDATE_TIMED 0x85
170#define PEER_MSG_STKT_INCUPDATE_TIMED 0x86
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +0200171/* All the stick-table message identifiers abova have the #7 bit set */
172#define PEER_MSG_STKT_BIT 7
173#define PEER_MSG_STKT_BIT_MASK (1 << PEER_MSG_STKT_BIT)
Emeric Brun2b920a12010-09-23 18:30:22 +0200174
Frédéric Lécaille39143342019-05-24 14:32:27 +0200175/* The maximum length of an encoded data length. */
176#define PEER_MSG_ENC_LENGTH_MAXLEN 5
177
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200178/* Minimum 64-bits value encoded with 2 bytes */
179#define PEER_ENC_2BYTES_MIN 0xf0 /* 0xf0 (or 240) */
180/* 3 bytes */
181#define PEER_ENC_3BYTES_MIN ((1ULL << 11) | PEER_ENC_2BYTES_MIN) /* 0x8f0 (or 2288) */
182/* 4 bytes */
183#define PEER_ENC_4BYTES_MIN ((1ULL << 18) | PEER_ENC_3BYTES_MIN) /* 0x408f0 (or 264432) */
184/* 5 bytes */
185#define PEER_ENC_5BYTES_MIN ((1ULL << 25) | PEER_ENC_4BYTES_MIN) /* 0x20408f0 (or 33818864) */
186/* 6 bytes */
187#define PEER_ENC_6BYTES_MIN ((1ULL << 32) | PEER_ENC_5BYTES_MIN) /* 0x1020408f0 (or 4328786160) */
188/* 7 bytes */
189#define PEER_ENC_7BYTES_MIN ((1ULL << 39) | PEER_ENC_6BYTES_MIN) /* 0x81020408f0 (or 554084600048) */
190/* 8 bytes */
191#define PEER_ENC_8BYTES_MIN ((1ULL << 46) | PEER_ENC_7BYTES_MIN) /* 0x4081020408f0 (or 70922828777712) */
192/* 9 bytes */
193#define PEER_ENC_9BYTES_MIN ((1ULL << 53) | PEER_ENC_8BYTES_MIN) /* 0x204081020408f0 (or 9078122083518704) */
194/* 10 bytes */
195#define PEER_ENC_10BYTES_MIN ((1ULL << 60) | PEER_ENC_9BYTES_MIN) /* 0x10204081020408f0 (or 1161999626690365680) */
196
197/* #7 bit used to detect the last byte to be encoded */
198#define PEER_ENC_STOP_BIT 7
199/* The byte minimum value with #7 bit set */
200#define PEER_ENC_STOP_BYTE (1 << PEER_ENC_STOP_BIT)
201/* The left most number of bits set for PEER_ENC_2BYTES_MIN */
202#define PEER_ENC_2BYTES_MIN_BITS 4
203
Frédéric Lécaille39143342019-05-24 14:32:27 +0200204#define PEER_MSG_HEADER_LEN 2
205
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200206#define PEER_STKT_CACHE_MAX_ENTRIES 128
207
Emeric Brun2b920a12010-09-23 18:30:22 +0200208/**********************************/
209/* Peer Session IO handler states */
210/**********************************/
211
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100212enum {
213 PEER_SESS_ST_ACCEPT = 0, /* Initial state for session create by an accept, must be zero! */
214 PEER_SESS_ST_GETVERSION, /* Validate supported protocol version */
215 PEER_SESS_ST_GETHOST, /* Validate host ID correspond to local host id */
216 PEER_SESS_ST_GETPEER, /* Validate peer ID correspond to a known remote peer id */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100217 /* after this point, data were possibly exchanged */
218 PEER_SESS_ST_SENDSUCCESS, /* Send ret code 200 (success) and wait for message */
219 PEER_SESS_ST_CONNECT, /* Initial state for session create on a connect, push presentation into buffer */
220 PEER_SESS_ST_GETSTATUS, /* Wait for the welcome message */
221 PEER_SESS_ST_WAITMSG, /* Wait for data messages */
222 PEER_SESS_ST_EXIT, /* Exit with status code */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200223 PEER_SESS_ST_ERRPROTO, /* Send error proto message before exit */
224 PEER_SESS_ST_ERRSIZE, /* Send error size message before exit */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100225 PEER_SESS_ST_END, /* Killed session */
226};
Emeric Brun2b920a12010-09-23 18:30:22 +0200227
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100228/***************************************************/
229/* Peer Session status code - part of the protocol */
230/***************************************************/
Emeric Brun2b920a12010-09-23 18:30:22 +0200231
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100232#define PEER_SESS_SC_CONNECTCODE 100 /* connect in progress */
233#define PEER_SESS_SC_CONNECTEDCODE 110 /* tcp connect success */
Emeric Brun2b920a12010-09-23 18:30:22 +0200234
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100235#define PEER_SESS_SC_SUCCESSCODE 200 /* accept or connect successful */
Emeric Brun2b920a12010-09-23 18:30:22 +0200236
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100237#define PEER_SESS_SC_TRYAGAIN 300 /* try again later */
Emeric Brun2b920a12010-09-23 18:30:22 +0200238
Frédéric Lécailleaba44a22019-03-26 10:18:07 +0100239#define PEER_SESS_SC_ERRPROTO 501 /* error protocol */
240#define PEER_SESS_SC_ERRVERSION 502 /* unknown protocol version */
241#define PEER_SESS_SC_ERRHOST 503 /* bad host name */
242#define PEER_SESS_SC_ERRPEER 504 /* unknown peer */
Emeric Brun2b920a12010-09-23 18:30:22 +0200243
244#define PEER_SESSION_PROTO_NAME "HAProxyS"
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200245#define PEER_MAJOR_VER 2
246#define PEER_MINOR_VER 1
247#define PEER_DWNGRD_MINOR_VER 0
Emeric Brun2b920a12010-09-23 18:30:22 +0200248
Willy Tarreau6254a922019-01-29 17:45:23 +0100249static size_t proto_len = sizeof(PEER_SESSION_PROTO_NAME) - 1;
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200250struct peers *cfg_peers = NULL;
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200251static void peer_session_forceshutdown(struct peer *peer);
Emeric Brun2b920a12010-09-23 18:30:22 +0200252
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200253static struct ebpt_node *dcache_tx_insert(struct dcache *dc,
254 struct dcache_tx_entry *i);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200255static inline void flush_dcache(struct peer *peer);
256
Frédéric Lécaille95679dc2019-04-15 10:25:27 +0200257static const char *statuscode_str(int statuscode)
258{
259 switch (statuscode) {
260 case PEER_SESS_SC_CONNECTCODE:
261 return "CONN";
262 case PEER_SESS_SC_CONNECTEDCODE:
263 return "HSHK";
264 case PEER_SESS_SC_SUCCESSCODE:
265 return "ESTA";
266 case PEER_SESS_SC_TRYAGAIN:
267 return "RETR";
268 case PEER_SESS_SC_ERRPROTO:
269 return "PROT";
270 case PEER_SESS_SC_ERRVERSION:
271 return "VERS";
272 case PEER_SESS_SC_ERRHOST:
273 return "NAME";
274 case PEER_SESS_SC_ERRPEER:
275 return "UNKN";
276 default:
277 return "NONE";
278 }
279}
280
Emeric Brun18928af2017-03-29 16:32:53 +0200281/* This function encode an uint64 to 'dynamic' length format.
282 The encoded value is written at address *str, and the
283 caller must assure that size after *str is large enought.
284 At return, the *str is set at the next Byte after then
285 encoded integer. The function returns then length of the
286 encoded integer in Bytes */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200287int intencode(uint64_t i, char **str) {
288 int idx = 0;
289 unsigned char *msg;
290
Emeric Brunb3971ab2015-05-12 18:49:09 +0200291 msg = (unsigned char *)*str;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200292 if (i < PEER_ENC_2BYTES_MIN) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200293 msg[0] = (unsigned char)i;
294 *str = (char *)&msg[idx+1];
295 return (idx+1);
296 }
297
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200298 msg[idx] =(unsigned char)i | PEER_ENC_2BYTES_MIN;
299 i = (i - PEER_ENC_2BYTES_MIN) >> PEER_ENC_2BYTES_MIN_BITS;
300 while (i >= PEER_ENC_STOP_BYTE) {
301 msg[++idx] = (unsigned char)i | PEER_ENC_STOP_BYTE;
302 i = (i - PEER_ENC_STOP_BYTE) >> PEER_ENC_STOP_BIT;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200303 }
304 msg[++idx] = (unsigned char)i;
305 *str = (char *)&msg[idx+1];
306 return (idx+1);
307}
308
309
310/* This function returns the decoded integer or 0
311 if decode failed
312 *str point on the beginning of the integer to decode
313 at the end of decoding *str point on the end of the
314 encoded integer or to null if end is reached */
Emeric Brun18928af2017-03-29 16:32:53 +0200315uint64_t intdecode(char **str, char *end)
316{
Emeric Brunb3971ab2015-05-12 18:49:09 +0200317 unsigned char *msg;
Emeric Brun18928af2017-03-29 16:32:53 +0200318 uint64_t i;
319 int shift;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200320
321 if (!*str)
322 return 0;
323
324 msg = (unsigned char *)*str;
Emeric Brun18928af2017-03-29 16:32:53 +0200325 if (msg >= (unsigned char *)end)
326 goto fail;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200327
Emeric Brun18928af2017-03-29 16:32:53 +0200328 i = *(msg++);
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200329 if (i >= PEER_ENC_2BYTES_MIN) {
330 shift = PEER_ENC_2BYTES_MIN_BITS;
Emeric Brun18928af2017-03-29 16:32:53 +0200331 do {
332 if (msg >= (unsigned char *)end)
333 goto fail;
334 i += (uint64_t)*msg << shift;
Frédéric Lécaille32b55732019-06-03 18:29:51 +0200335 shift += PEER_ENC_STOP_BIT;
336 } while (*(msg++) >= PEER_ENC_STOP_BYTE);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200337 }
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100338 *str = (char *)msg;
339 return i;
Emeric Brun18928af2017-03-29 16:32:53 +0200340
Frédéric Lécaillea8725ec2019-01-22 10:31:39 +0100341 fail:
342 *str = NULL;
343 return 0;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200344}
Emeric Brun2b920a12010-09-23 18:30:22 +0200345
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100346/*
347 * Build a "hello" peer protocol message.
348 * Return the number of written bytes written to build this messages if succeeded,
349 * 0 if not.
350 */
351static int peer_prepare_hellomsg(char *msg, size_t size, struct peer_prep_params *p)
352{
353 int min_ver, ret;
354 struct peer *peer;
355
356 peer = p->hello.peer;
357 min_ver = (peer->flags & PEER_F_DWNGRD) ? PEER_DWNGRD_MINOR_VER : PEER_MINOR_VER;
358 /* Prepare headers */
359 ret = snprintf(msg, size, PEER_SESSION_PROTO_NAME " %u.%u\n%s\n%s %d %d\n",
360 PEER_MAJOR_VER, min_ver, peer->id, localpeer, (int)getpid(), relative_pid);
361 if (ret >= size)
362 return 0;
363
364 return ret;
365}
366
367/*
368 * Build a "handshake succeeded" status message.
369 * Return the number of written bytes written to build this messages if succeeded,
370 * 0 if not.
371 */
372static int peer_prepare_status_successmsg(char *msg, size_t size, struct peer_prep_params *p)
373{
374 int ret;
375
376 ret = snprintf(msg, size, "%d\n", PEER_SESS_SC_SUCCESSCODE);
377 if (ret >= size)
378 return 0;
379
380 return ret;
381}
382
383/*
384 * Build an error status message.
385 * Return the number of written bytes written to build this messages if succeeded,
386 * 0 if not.
387 */
388static int peer_prepare_status_errormsg(char *msg, size_t size, struct peer_prep_params *p)
389{
390 int ret;
391 unsigned int st1;
392
393 st1 = p->error_status.st1;
394 ret = snprintf(msg, size, "%d\n", st1);
395 if (ret >= size)
396 return 0;
397
398 return ret;
399}
400
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200401/* Set the stick-table UPDATE message type byte at <msg_type> address,
402 * depending on <use_identifier> and <use_timed> boolean parameters.
403 * Always successful.
404 */
405static inline void peer_set_update_msg_type(char *msg_type, int use_identifier, int use_timed)
406{
407 if (use_timed) {
408 if (use_identifier)
409 *msg_type = PEER_MSG_STKT_UPDATE_TIMED;
410 else
411 *msg_type = PEER_MSG_STKT_INCUPDATE_TIMED;
412 }
413 else {
414 if (use_identifier)
415 *msg_type = PEER_MSG_STKT_UPDATE;
416 else
417 *msg_type = PEER_MSG_STKT_INCUPDATE;
418 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200419}
Emeric Brun2b920a12010-09-23 18:30:22 +0200420/*
Emeric Brunb3971ab2015-05-12 18:49:09 +0200421 * This prepare the data update message on the stick session <ts>, <st> is the considered
422 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800423 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200424 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
425 * check size)
Emeric Brun2b920a12010-09-23 18:30:22 +0200426 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100427static int peer_prepare_updatemsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brun2b920a12010-09-23 18:30:22 +0200428{
429 uint32_t netinteger;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200430 unsigned short datalen;
431 char *cursor, *datamsg;
Emeric Brun94900952015-06-11 18:25:54 +0200432 unsigned int data_type;
433 void *data_ptr;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100434 struct stksess *ts;
435 struct shared_table *st;
436 unsigned int updateid;
437 int use_identifier;
438 int use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200439 struct peer *peer;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100440
441 ts = p->updt.stksess;
442 st = p->updt.shared_table;
443 updateid = p->updt.updateid;
444 use_identifier = p->updt.use_identifier;
445 use_timed = p->updt.use_timed;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200446 peer = p->updt.peer;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200447
Frédéric Lécaille0e8db972019-05-24 14:34:34 +0200448 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200449
Emeric Brun2b920a12010-09-23 18:30:22 +0200450 /* construct message */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200451
452 /* check if we need to send the update identifer */
Emeric Brun819fc6f2017-06-13 19:37:32 +0200453 if (!st->last_pushed || updateid < st->last_pushed || ((updateid - st->last_pushed) != 1)) {
Emeric Bruna6a09982015-09-22 15:34:19 +0200454 use_identifier = 1;
Emeric Brun2b920a12010-09-23 18:30:22 +0200455 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200456
457 /* encode update identifier if needed */
458 if (use_identifier) {
Emeric Brun819fc6f2017-06-13 19:37:32 +0200459 netinteger = htonl(updateid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200460 memcpy(cursor, &netinteger, sizeof(netinteger));
461 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200462 }
463
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200464 if (use_timed) {
465 netinteger = htonl(tick_remain(now_ms, ts->expire));
466 memcpy(cursor, &netinteger, sizeof(netinteger));
467 cursor += sizeof(netinteger);
468 }
469
Emeric Brunb3971ab2015-05-12 18:49:09 +0200470 /* encode the key */
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200471 if (st->table->type == SMP_T_STR) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200472 int stlen = strlen((char *)ts->key.key);
473
Emeric Brunb3971ab2015-05-12 18:49:09 +0200474 intencode(stlen, &cursor);
475 memcpy(cursor, ts->key.key, stlen);
476 cursor += stlen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200477 }
Thierry FOURNIER5d24ebc2015-07-24 08:46:42 +0200478 else if (st->table->type == SMP_T_SINT) {
Emeric Brun2b920a12010-09-23 18:30:22 +0200479 netinteger = htonl(*((uint32_t *)ts->key.key));
Emeric Brunb3971ab2015-05-12 18:49:09 +0200480 memcpy(cursor, &netinteger, sizeof(netinteger));
481 cursor += sizeof(netinteger);
Emeric Brun2b920a12010-09-23 18:30:22 +0200482 }
483 else {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200484 memcpy(cursor, ts->key.key, st->table->key_size);
485 cursor += st->table->key_size;
Emeric Brun2b920a12010-09-23 18:30:22 +0200486 }
487
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100488 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200489 /* encode values */
Emeric Brun94900952015-06-11 18:25:54 +0200490 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Emeric Brunb3971ab2015-05-12 18:49:09 +0200491
Emeric Brun94900952015-06-11 18:25:54 +0200492 data_ptr = stktable_data_ptr(st->table, ts, data_type);
493 if (data_ptr) {
494 switch (stktable_data_types[data_type].std_type) {
495 case STD_T_SINT: {
496 int data;
497
498 data = stktable_data_cast(data_ptr, std_t_sint);
499 intencode(data, &cursor);
500 break;
501 }
502 case STD_T_UINT: {
503 unsigned int data;
504
505 data = stktable_data_cast(data_ptr, std_t_uint);
506 intencode(data, &cursor);
507 break;
508 }
509 case STD_T_ULL: {
510 unsigned long long data;
511
512 data = stktable_data_cast(data_ptr, std_t_ull);
513 intencode(data, &cursor);
514 break;
515 }
516 case STD_T_FRQP: {
517 struct freq_ctr_period *frqp;
518
519 frqp = &stktable_data_cast(data_ptr, std_t_frqp);
520 intencode((unsigned int)(now_ms - frqp->curr_tick), &cursor);
521 intencode(frqp->curr_ctr, &cursor);
522 intencode(frqp->prev_ctr, &cursor);
523 break;
524 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200525 case STD_T_DICT: {
526 struct dict_entry *de;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200527 struct ebpt_node *cached_de;
Willy Tarreau237f8ae2019-06-06 16:40:43 +0200528 struct dcache_tx_entry cde = { };
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200529 char *beg, *end;
530 size_t value_len, data_len;
531 struct dcache *dc;
532
533 de = stktable_data_cast(data_ptr, std_t_dict);
534 if (!de)
535 break;
536
537 dc = peer->dcache;
Frédéric Lécaille6c391982019-06-06 11:34:03 +0200538 cde.entry.key = de;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200539 cached_de = dcache_tx_insert(dc, &cde);
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200540 if (cached_de == &cde.entry) {
541 if (cde.id + 1 >= PEER_ENC_2BYTES_MIN)
542 break;
543 /* Encode the length of the remaining data -> 1 */
544 intencode(1, &cursor);
545 /* Encode the cache entry ID */
546 intencode(cde.id + 1, &cursor);
547 }
548 else {
549 /* Leave enough room to encode the remaining data length. */
550 end = beg = cursor + PEER_MSG_ENC_LENGTH_MAXLEN;
551 /* Encode the dictionary entry key */
552 intencode(cde.id + 1, &end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200553 /* Encode the length of the dictionary entry data */
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200554 value_len = de->len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200555 intencode(value_len, &end);
556 /* Copy the data */
557 memcpy(end, de->value.key, value_len);
558 end += value_len;
Frédéric Lécaillefd827932019-06-07 10:34:04 +0200559 /* Encode the length of the data */
560 data_len = end - beg;
561 intencode(data_len, &cursor);
562 memmove(cursor, beg, data_len);
563 cursor += data_len;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200564 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200565 break;
566 }
Emeric Brun94900952015-06-11 18:25:54 +0200567 }
568 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200569 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100570 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200571
572 /* Compute datalen */
573 datalen = (cursor - datamsg);
574
575 /* prepare message header */
576 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200577 peer_set_update_msg_type(&msg[1], use_identifier, use_timed);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200578 cursor = &msg[2];
579 intencode(datalen, &cursor);
580
581 /* move data after header */
582 memmove(cursor, datamsg, datalen);
583
584 /* return header size + data_len */
585 return (cursor - msg) + datalen;
586}
587
588/*
589 * This prepare the switch table message to targeted share table <st>.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800590 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200591 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
592 * check size)
593 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100594static int peer_prepare_switchmsg(char *msg, size_t size, struct peer_prep_params *params)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200595{
596 int len;
597 unsigned short datalen;
Willy Tarreau83061a82018-07-13 11:56:34 +0200598 struct buffer *chunk;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200599 char *cursor, *datamsg, *chunkp, *chunkq;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200600 uint64_t data = 0;
Emeric Brun94900952015-06-11 18:25:54 +0200601 unsigned int data_type;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100602 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200603
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100604 st = params->swtch.shared_table;
Frédéric Lécaille39143342019-05-24 14:32:27 +0200605 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200606
607 /* Encode data */
608
609 /* encode local id */
610 intencode(st->local_id, &cursor);
611
612 /* encode table name */
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100613 len = strlen(st->table->nid);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200614 intencode(len, &cursor);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100615 memcpy(cursor, st->table->nid, len);
Emeric Brunb3971ab2015-05-12 18:49:09 +0200616 cursor += len;
617
618 /* encode table type */
619
620 intencode(st->table->type, &cursor);
621
622 /* encode table key size */
623 intencode(st->table->key_size, &cursor);
624
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200625 chunk = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200626 chunkp = chunkq = chunk->area;
Emeric Brun94900952015-06-11 18:25:54 +0200627 /* encode available known data types in table */
628 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
629 if (st->table->data_ofs[data_type]) {
630 switch (stktable_data_types[data_type].std_type) {
631 case STD_T_SINT:
632 case STD_T_UINT:
633 case STD_T_ULL:
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200634 case STD_T_DICT:
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200635 data |= 1 << data_type;
636 break;
Emeric Brun94900952015-06-11 18:25:54 +0200637 case STD_T_FRQP:
638 data |= 1 << data_type;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200639 intencode(data_type, &chunkq);
640 intencode(st->table->data_arg[data_type].u, &chunkq);
Emeric Brun94900952015-06-11 18:25:54 +0200641 break;
642 }
643 }
Emeric Brunb3971ab2015-05-12 18:49:09 +0200644 }
645 intencode(data, &cursor);
646
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200647 /* Encode stick-table entries duration. */
648 intencode(st->table->expire, &cursor);
649
650 if (chunkq > chunkp) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200651 chunk->data = chunkq - chunkp;
652 memcpy(cursor, chunk->area, chunk->data);
653 cursor += chunk->data;
Frédéric Lécaille37a72542017-07-06 15:02:16 +0200654 }
655
Emeric Brunb3971ab2015-05-12 18:49:09 +0200656 /* Compute datalen */
657 datalen = (cursor - datamsg);
Emeric Brun2b920a12010-09-23 18:30:22 +0200658
Emeric Brunb3971ab2015-05-12 18:49:09 +0200659 /* prepare message header */
660 msg[0] = PEER_MSG_CLASS_STICKTABLE;
661 msg[1] = PEER_MSG_STKT_DEFINE;
662 cursor = &msg[2];
663 intencode(datalen, &cursor);
Emeric Brun2b920a12010-09-23 18:30:22 +0200664
Emeric Brunb3971ab2015-05-12 18:49:09 +0200665 /* move data after header */
666 memmove(cursor, datamsg, datalen);
667
668 /* return header size + data_len */
669 return (cursor - msg) + datalen;
Emeric Brun2b920a12010-09-23 18:30:22 +0200670}
671
Emeric Brunb3971ab2015-05-12 18:49:09 +0200672/*
673 * This prepare the acknowledge message on the stick session <ts>, <st> is the considered
674 * stick table.
Joseph Herlant82b2f542018-11-15 12:19:14 -0800675 * <msg> is a buffer of <size> to receive data message content
Emeric Brunb3971ab2015-05-12 18:49:09 +0200676 * If function returns 0, the caller should consider we were unable to encode this message (TODO:
677 * check size)
678 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100679static int peer_prepare_ackmsg(char *msg, size_t size, struct peer_prep_params *p)
Emeric Brunb3971ab2015-05-12 18:49:09 +0200680{
681 unsigned short datalen;
682 char *cursor, *datamsg;
683 uint32_t netinteger;
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100684 struct shared_table *st;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200685
Frédéric Lécaille39143342019-05-24 14:32:27 +0200686 cursor = datamsg = msg + PEER_MSG_HEADER_LEN + PEER_MSG_ENC_LENGTH_MAXLEN;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200687
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100688 st = p->ack.shared_table;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200689 intencode(st->remote_id, &cursor);
690 netinteger = htonl(st->last_get);
691 memcpy(cursor, &netinteger, sizeof(netinteger));
692 cursor += sizeof(netinteger);
693
694 /* Compute datalen */
695 datalen = (cursor - datamsg);
696
697 /* prepare message header */
698 msg[0] = PEER_MSG_CLASS_STICKTABLE;
Emeric Brune1ab8082015-08-21 11:48:54 +0200699 msg[1] = PEER_MSG_STKT_ACK;
Emeric Brunb3971ab2015-05-12 18:49:09 +0200700 cursor = &msg[2];
701 intencode(datalen, &cursor);
702
703 /* move data after header */
704 memmove(cursor, datamsg, datalen);
705
706 /* return header size + data_len */
707 return (cursor - msg) + datalen;
708}
Emeric Brun2b920a12010-09-23 18:30:22 +0200709
710/*
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200711 * Function to deinit connected peer
712 */
713void __peer_session_deinit(struct peer *peer)
714{
715 struct stream_interface *si;
716 struct stream *s;
717 struct peers *peers;
718
719 if (!peer->appctx)
720 return;
721
722 si = peer->appctx->owner;
723 if (!si)
724 return;
725
726 s = si_strm(si);
727 if (!s)
728 return;
729
730 peers = strm_fe(s)->parent;
731 if (!peers)
732 return;
733
734 if (peer->appctx->st0 == PEER_SESS_ST_WAITMSG)
735 HA_ATOMIC_SUB(&connected_peers, 1);
736
737 HA_ATOMIC_SUB(&active_peers, 1);
738
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200739 flush_dcache(peer);
740
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200741 /* Re-init current table pointers to force announcement on re-connect */
742 peer->remote_table = peer->last_local_table = NULL;
743 peer->appctx = NULL;
744 if (peer->flags & PEER_F_LEARN_ASSIGN) {
745 /* unassign current peer for learning */
746 peer->flags &= ~(PEER_F_LEARN_ASSIGN);
747 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
748
749 /* reschedule a resync */
750 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
751 }
752 /* reset teaching and learning flags to 0 */
753 peer->flags &= PEER_TEACH_RESET;
754 peer->flags &= PEER_LEARN_RESET;
755 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
756}
757
758/*
Emeric Brun2b920a12010-09-23 18:30:22 +0200759 * Callback to release a session with a peer
760 */
Willy Tarreau00a37f02015-04-13 12:05:19 +0200761static void peer_session_release(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +0200762{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200763 struct peer *peer = appctx->ctx.peers.ptr;
Emeric Brun2b920a12010-09-23 18:30:22 +0200764
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100765 /* appctx->ctx.peers.ptr is not a peer session */
Willy Tarreaue4d927a2013-12-01 12:47:35 +0100766 if (appctx->st0 < PEER_SESS_ST_SENDSUCCESS)
Emeric Brun2b920a12010-09-23 18:30:22 +0200767 return;
768
769 /* peer session identified */
Emeric Brunb3971ab2015-05-12 18:49:09 +0200770 if (peer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100771 HA_SPIN_LOCK(PEER_LOCK, &peer->lock);
Emeric Brun9ef2ad72019-04-02 17:22:01 +0200772 if (peer->appctx == appctx)
773 __peer_session_deinit(peer);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100774 HA_SPIN_UNLOCK(PEER_LOCK, &peer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +0200775 }
776}
777
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +0200778/* Retrieve the major and minor versions of peers protocol
779 * announced by a remote peer. <str> is a null-terminated
780 * string with the following format: "<maj_ver>.<min_ver>".
781 */
782static int peer_get_version(const char *str,
783 unsigned int *maj_ver, unsigned int *min_ver)
784{
785 unsigned int majv, minv;
786 const char *pos, *saved;
787 const char *end;
788
789 saved = pos = str;
790 end = str + strlen(str);
791
792 majv = read_uint(&pos, end);
793 if (saved == pos || *pos++ != '.')
794 return -1;
795
796 saved = pos;
797 minv = read_uint(&pos, end);
798 if (saved == pos || pos != end)
799 return -1;
800
801 *maj_ver = majv;
802 *min_ver = minv;
803
804 return 0;
805}
Emeric Brun2b920a12010-09-23 18:30:22 +0200806
807/*
Frédéric Lécaillece025572019-01-21 13:38:06 +0100808 * Parse a line terminated by an optional '\r' character, followed by a mandatory
809 * '\n' character.
810 * Returns 1 if succeeded or 0 if a '\n' character could not be found, and -1 if
811 * a line could not be read because the communication channel is closed.
812 */
813static inline int peer_getline(struct appctx *appctx)
814{
815 int n;
816 struct stream_interface *si = appctx->owner;
817
818 n = co_getline(si_oc(si), trash.area, trash.size);
819 if (!n)
820 return 0;
821
822 if (n < 0 || trash.area[n - 1] != '\n') {
823 appctx->st0 = PEER_SESS_ST_END;
824 return -1;
825 }
826
827 if (n > 1 && (trash.area[n - 2] == '\r'))
828 trash.area[n - 2] = 0;
829 else
830 trash.area[n - 1] = 0;
831
832 co_skip(si_oc(si), n);
833
834 return n;
835}
836
837/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100838 * Send a message after having called <peer_prepare_msg> to build it.
839 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
840 * Returns -1 if there was not enough room left to send the message,
841 * any other negative returned value must be considered as an error with an appcxt st0
842 * returned value equal to PEER_SESS_ST_END.
843 */
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100844static inline int peer_send_msg(struct appctx *appctx,
845 int (*peer_prepare_msg)(char *, size_t, struct peer_prep_params *),
846 struct peer_prep_params *params)
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100847{
848 int ret, msglen;
849 struct stream_interface *si = appctx->owner;
850
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100851 msglen = peer_prepare_msg(trash.area, trash.size, params);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100852 if (!msglen) {
853 /* internal error: message does not fit in trash */
854 appctx->st0 = PEER_SESS_ST_END;
855 return 0;
856 }
857
858 /* message to buffer */
859 ret = ci_putblk(si_ic(si), trash.area, msglen);
860 if (ret <= 0) {
861 if (ret == -1) {
862 /* No more write possible */
863 si_rx_room_blk(si);
864 return -1;
865 }
866 appctx->st0 = PEER_SESS_ST_END;
867 }
868
869 return ret;
870}
871
872/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100873 * Send a hello message.
874 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
875 * Returns -1 if there was not enough room left to send the message,
876 * any other negative returned value must be considered as an error with an appcxt st0
877 * returned value equal to PEER_SESS_ST_END.
878 */
879static inline int peer_send_hellomsg(struct appctx *appctx, struct peer *peer)
880{
881 struct peer_prep_params p = {
882 .hello.peer = peer,
883 };
884
885 return peer_send_msg(appctx, peer_prepare_hellomsg, &p);
886}
887
888/*
889 * Send a success peer handshake status message.
890 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
891 * Returns -1 if there was not enough room left to send the message,
892 * any other negative returned value must be considered as an error with an appcxt st0
893 * returned value equal to PEER_SESS_ST_END.
894 */
895static inline int peer_send_status_successmsg(struct appctx *appctx)
896{
897 return peer_send_msg(appctx, peer_prepare_status_successmsg, NULL);
898}
899
900/*
901 * Send a peer handshake status error message.
902 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
903 * Returns -1 if there was not enough room left to send the message,
904 * any other negative returned value must be considered as an error with an appcxt st0
905 * returned value equal to PEER_SESS_ST_END.
906 */
907static inline int peer_send_status_errormsg(struct appctx *appctx)
908{
909 struct peer_prep_params p = {
910 .error_status.st1 = appctx->st1,
911 };
912
913 return peer_send_msg(appctx, peer_prepare_status_errormsg, &p);
914}
915
916/*
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100917 * Send a stick-table switch message.
918 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
919 * Returns -1 if there was not enough room left to send the message,
920 * any other negative returned value must be considered as an error with an appcxt st0
921 * returned value equal to PEER_SESS_ST_END.
922 */
923static inline int peer_send_switchmsg(struct shared_table *st, struct appctx *appctx)
924{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100925 struct peer_prep_params p = {
926 .swtch.shared_table = st,
927 };
928
929 return peer_send_msg(appctx, peer_prepare_switchmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100930}
931
932/*
933 * Send a stick-table update acknowledgement message.
934 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
935 * Returns -1 if there was not enough room left to send the message,
936 * any other negative returned value must be considered as an error with an appcxt st0
937 * returned value equal to PEER_SESS_ST_END.
938 */
939static inline int peer_send_ackmsg(struct shared_table *st, struct appctx *appctx)
940{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100941 struct peer_prep_params p = {
942 .ack.shared_table = st,
943 };
944
945 return peer_send_msg(appctx, peer_prepare_ackmsg, &p);
Frédéric Lécailleec44ea82019-01-22 15:54:53 +0100946}
947
948/*
Frédéric Lécaille87f554c2019-01-22 17:26:50 +0100949 * Send a stick-table update message.
950 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
951 * Returns -1 if there was not enough room left to send the message,
952 * any other negative returned value must be considered as an error with an appcxt st0
953 * returned value equal to PEER_SESS_ST_END.
954 */
955static inline int peer_send_updatemsg(struct shared_table *st, struct appctx *appctx, struct stksess *ts,
956 unsigned int updateid, int use_identifier, int use_timed)
957{
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100958 struct peer_prep_params p = {
959 .updt.stksess = ts,
960 .updt.shared_table = st,
961 .updt.updateid = updateid,
962 .updt.use_identifier = use_identifier,
963 .updt.use_timed = use_timed,
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +0200964 .updt.peer = appctx->ctx.peers.ptr,
Frédéric Lécailled5fe14b2019-01-24 10:33:40 +0100965 };
966
967 return peer_send_msg(appctx, peer_prepare_updatemsg, &p);
Frédéric Lécaille87f554c2019-01-22 17:26:50 +0100968}
969
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100970/*
971 * Build a peer protocol control class message.
972 * Returns the number of written bytes used to build the message if succeeded,
973 * 0 if not.
974 */
975static int peer_prepare_control_msg(char *msg, size_t size, struct peer_prep_params *p)
976{
977 if (size < sizeof p->control.head)
978 return 0;
979
980 msg[0] = p->control.head[0];
981 msg[1] = p->control.head[1];
982
983 return 2;
984}
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +0100985
986/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +0100987 * Send a stick-table synchronization request message.
988 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
989 * Returns -1 if there was not enough room left to send the message,
990 * any other negative returned value must be considered as an error with an appctx st0
991 * returned value equal to PEER_SESS_ST_END.
992 */
993static inline int peer_send_resync_reqmsg(struct appctx *appctx)
994{
995 struct peer_prep_params p = {
996 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCREQ, },
997 };
998
999 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1000}
1001
1002/*
1003 * Send a stick-table synchronization confirmation message.
1004 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1005 * Returns -1 if there was not enough room left to send the message,
1006 * any other negative returned value must be considered as an error with an appctx st0
1007 * returned value equal to PEER_SESS_ST_END.
1008 */
1009static inline int peer_send_resync_confirmsg(struct appctx *appctx)
1010{
1011 struct peer_prep_params p = {
1012 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_RESYNCCONFIRM, },
1013 };
1014
1015 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1016}
1017
1018/*
1019 * Send a stick-table synchronization finished message.
1020 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1021 * Returns -1 if there was not enough room left to send the message,
1022 * any other negative returned value must be considered as an error with an appctx st0
1023 * returned value equal to PEER_SESS_ST_END.
1024 */
1025static inline int peer_send_resync_finishedmsg(struct appctx *appctx, struct peer *peer)
1026{
1027 struct peer_prep_params p = {
1028 .control.head = { PEER_MSG_CLASS_CONTROL, },
1029 };
1030
1031 p.control.head[1] = (peer->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED ?
1032 PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
1033
1034 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1035}
1036
1037/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001038 * Send a heartbeat message.
1039 * Return 0 if the message could not be built modifying the appctx st0 to PEER_SESS_ST_END value.
1040 * Returns -1 if there was not enough room left to send the message,
1041 * any other negative returned value must be considered as an error with an appctx st0
1042 * returned value equal to PEER_SESS_ST_END.
1043 */
1044static inline int peer_send_heartbeatmsg(struct appctx *appctx)
1045{
1046 struct peer_prep_params p = {
1047 .control.head = { PEER_MSG_CLASS_CONTROL, PEER_MSG_CTRL_HEARTBEAT, },
1048 };
1049
1050 return peer_send_msg(appctx, peer_prepare_control_msg, &p);
1051}
1052
1053/*
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01001054 * Build a peer protocol error class message.
1055 * Returns the number of written bytes used to build the message if succeeded,
1056 * 0 if not.
1057 */
1058static int peer_prepare_error_msg(char *msg, size_t size, struct peer_prep_params *p)
1059{
1060 if (size < sizeof p->error.head)
1061 return 0;
1062
1063 msg[0] = p->error.head[0];
1064 msg[1] = p->error.head[1];
1065
1066 return 2;
1067}
1068
1069/*
1070 * Send a "size limit reached" error message.
1071 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1072 * Returns -1 if there was not enough room left to send the message,
1073 * any other negative returned value must be considered as an error with an appctx st0
1074 * returned value equal to PEER_SESS_ST_END.
1075 */
1076static inline int peer_send_error_size_limitmsg(struct appctx *appctx)
1077{
1078 struct peer_prep_params p = {
1079 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_SIZELIMIT, },
1080 };
1081
1082 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1083}
1084
1085/*
1086 * Send a "peer protocol" error message.
1087 * Return 0 if the message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1088 * Returns -1 if there was not enough room left to send the message,
1089 * any other negative returned value must be considered as an error with an appctx st0
1090 * returned value equal to PEER_SESS_ST_END.
1091 */
1092static inline int peer_send_error_protomsg(struct appctx *appctx)
1093{
1094 struct peer_prep_params p = {
1095 .error.head = { PEER_MSG_CLASS_ERROR, PEER_MSG_ERR_PROTOCOL, },
1096 };
1097
1098 return peer_send_msg(appctx, peer_prepare_error_msg, &p);
1099}
1100
1101/*
Frédéric Lécaille6a8303d2019-01-22 22:25:17 +01001102 * Function used to lookup for recent stick-table updates associated with
1103 * <st> shared stick-table when a lesson must be taught a peer (PEER_F_LEARN_ASSIGN flag set).
1104 */
1105static inline struct stksess *peer_teach_process_stksess_lookup(struct shared_table *st)
1106{
1107 struct eb32_node *eb;
1108
1109 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1110 if (!eb) {
1111 eb = eb32_first(&st->table->updates);
1112 if (!eb || ((int)(eb->key - st->last_pushed) <= 0)) {
1113 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1114 return NULL;
1115 }
1116 }
1117
1118 if ((int)(eb->key - st->table->localupdate) > 0) {
1119 st->table->commitupdate = st->last_pushed = st->table->localupdate;
1120 return NULL;
1121 }
1122
1123 return eb32_entry(eb, struct stksess, upd);
1124}
1125
1126/*
1127 * Function used to lookup for recent stick-table updates associated with
1128 * <st> shared stick-table during teach state 1 step.
1129 */
1130static inline struct stksess *peer_teach_stage1_stksess_lookup(struct shared_table *st)
1131{
1132 struct eb32_node *eb;
1133
1134 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1135 if (!eb) {
1136 st->flags |= SHTABLE_F_TEACH_STAGE1;
1137 eb = eb32_first(&st->table->updates);
1138 if (eb)
1139 st->last_pushed = eb->key - 1;
1140 return NULL;
1141 }
1142
1143 return eb32_entry(eb, struct stksess, upd);
1144}
1145
1146/*
1147 * Function used to lookup for recent stick-table updates associated with
1148 * <st> shared stick-table during teach state 2 step.
1149 */
1150static inline struct stksess *peer_teach_stage2_stksess_lookup(struct shared_table *st)
1151{
1152 struct eb32_node *eb;
1153
1154 eb = eb32_lookup_ge(&st->table->updates, st->last_pushed+1);
1155 if (!eb || eb->key > st->teaching_origin) {
1156 st->flags |= SHTABLE_F_TEACH_STAGE2;
1157 return NULL;
1158 }
1159
1160 return eb32_entry(eb, struct stksess, upd);
1161}
1162
1163/*
1164 * Generic function to emit update messages for <st> stick-table when a lesson must
1165 * be taught to the peer <p>.
1166 * <locked> must be set to 1 if the shared table <st> is already locked when entering
1167 * this function, 0 if not.
1168 *
1169 * This function temporary unlock/lock <st> when it sends stick-table updates or
1170 * when decrementing its refcount in case of any error when it sends this updates.
1171 *
1172 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1173 * Returns -1 if there was not enough room left to send the message,
1174 * any other negative returned value must be considered as an error with an appcxt st0
1175 * returned value equal to PEER_SESS_ST_END.
1176 * If it returns 0 or -1, this function leave <st> locked if already locked when entering this function
1177 * unlocked if not already locked when entering this function.
1178 */
1179static inline int peer_send_teachmsgs(struct appctx *appctx, struct peer *p,
1180 struct stksess *(*peer_stksess_lookup)(struct shared_table *),
1181 struct shared_table *st, int locked)
1182{
1183 int ret, new_pushed, use_timed;
1184
1185 ret = 1;
1186 use_timed = 0;
1187 if (st != p->last_local_table) {
1188 ret = peer_send_switchmsg(st, appctx);
1189 if (ret <= 0)
1190 return ret;
1191
1192 p->last_local_table = st;
1193 }
1194
1195 if (peer_stksess_lookup != peer_teach_process_stksess_lookup)
1196 use_timed = !(p->flags & PEER_F_DWNGRD);
1197
1198 /* We force new pushed to 1 to force identifier in update message */
1199 new_pushed = 1;
1200
1201 if (!locked)
1202 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1203
1204 while (1) {
1205 struct stksess *ts;
1206 unsigned updateid;
1207
1208 /* push local updates */
1209 ts = peer_stksess_lookup(st);
1210 if (!ts)
1211 break;
1212
1213 updateid = ts->upd.key;
1214 ts->ref_cnt++;
1215 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1216
1217 ret = peer_send_updatemsg(st, appctx, ts, updateid, new_pushed, use_timed);
1218 if (ret <= 0) {
1219 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1220 ts->ref_cnt--;
1221 if (!locked)
1222 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1223 return ret;
1224 }
1225
1226 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1227 ts->ref_cnt--;
1228 st->last_pushed = updateid;
1229
1230 if (peer_stksess_lookup == peer_teach_process_stksess_lookup &&
1231 (int)(st->last_pushed - st->table->commitupdate) > 0)
1232 st->table->commitupdate = st->last_pushed;
1233
1234 /* identifier may not needed in next update message */
1235 new_pushed = 0;
1236 }
1237
1238 out:
1239 if (!locked)
1240 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1241 return 1;
1242}
1243
1244/*
1245 * Function to emit update messages for <st> stick-table when a lesson must
1246 * be taught to the peer <p> (PEER_F_LEARN_ASSIGN flag set).
1247 *
1248 * Note that <st> shared stick-table is locked when calling this function.
1249 *
1250 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1251 * Returns -1 if there was not enough room left to send the message,
1252 * any other negative returned value must be considered as an error with an appcxt st0
1253 * returned value equal to PEER_SESS_ST_END.
1254 */
1255static inline int peer_send_teach_process_msgs(struct appctx *appctx, struct peer *p,
1256 struct shared_table *st)
1257{
1258 return peer_send_teachmsgs(appctx, p, peer_teach_process_stksess_lookup, st, 1);
1259}
1260
1261/*
1262 * Function to emit update messages for <st> stick-table when a lesson must
1263 * be taught to the peer <p> during teach state 1 step.
1264 *
1265 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1266 * Returns -1 if there was not enough room left to send the message,
1267 * any other negative returned value must be considered as an error with an appcxt st0
1268 * returned value equal to PEER_SESS_ST_END.
1269 */
1270static inline int peer_send_teach_stage1_msgs(struct appctx *appctx, struct peer *p,
1271 struct shared_table *st)
1272{
1273 return peer_send_teachmsgs(appctx, p, peer_teach_stage1_stksess_lookup, st, 0);
1274}
1275
1276/*
1277 * Function to emit update messages for <st> stick-table when a lesson must
1278 * be taught to the peer <p> during teach state 1 step.
1279 *
1280 * Return 0 if any message could not be built modifying the appcxt st0 to PEER_SESS_ST_END value.
1281 * Returns -1 if there was not enough room left to send the message,
1282 * any other negative returned value must be considered as an error with an appcxt st0
1283 * returned value equal to PEER_SESS_ST_END.
1284 */
1285static inline int peer_send_teach_stage2_msgs(struct appctx *appctx, struct peer *p,
1286 struct shared_table *st)
1287{
1288 return peer_send_teachmsgs(appctx, p, peer_teach_stage2_stksess_lookup, st, 0);
1289}
1290
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001291
1292/*
1293 * Function used to parse a stick-table update message after it has been received
1294 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1295 * receipt buffer with <msg_end> being position of the end of the stick-table message.
1296 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1297 * was encountered.
1298 * <exp> must be set if the stick-table entry expires.
1299 * <updt> must be set for PEER_MSG_STKT_UPDATE or PEER_MSG_STKT_UPDATE_TIMED stick-table
1300 * messages, in this case the stick-table udpate message is received with a stick-table
1301 * update ID.
1302 * <totl> is the length of the stick-table update message computed upon receipt.
1303 */
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001304static int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int exp,
1305 char **msg_cur, char *msg_end, int msg_len, int totl)
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001306{
1307 struct stream_interface *si = appctx->owner;
1308 struct shared_table *st = p->remote_table;
1309 struct stksess *ts, *newts;
1310 uint32_t update;
1311 int expire;
1312 unsigned int data_type;
1313 void *data_ptr;
1314
1315 /* Here we have data message */
1316 if (!st)
1317 goto ignore_msg;
1318
1319 expire = MS_TO_TICKS(st->table->expire);
1320
1321 if (updt) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001322 if (msg_len < sizeof(update))
1323 goto malformed_exit;
1324
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001325 memcpy(&update, *msg_cur, sizeof(update));
1326 *msg_cur += sizeof(update);
1327 st->last_get = htonl(update);
1328 }
1329 else {
1330 st->last_get++;
1331 }
1332
1333 if (exp) {
1334 size_t expire_sz = sizeof expire;
1335
Willy Tarreau1e82a142019-01-29 11:08:06 +01001336 if (*msg_cur + expire_sz > msg_end)
1337 goto malformed_exit;
1338
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001339 memcpy(&expire, *msg_cur, expire_sz);
1340 *msg_cur += expire_sz;
1341 expire = ntohl(expire);
1342 }
1343
1344 newts = stksess_new(st->table, NULL);
1345 if (!newts)
1346 goto ignore_msg;
1347
1348 if (st->table->type == SMP_T_STR) {
1349 unsigned int to_read, to_store;
1350
1351 to_read = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001352 if (!*msg_cur)
1353 goto malformed_free_newts;
1354
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001355 to_store = MIN(to_read, st->table->key_size - 1);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001356 if (*msg_cur + to_store > msg_end)
1357 goto malformed_free_newts;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001358
1359 memcpy(newts->key.key, *msg_cur, to_store);
1360 newts->key.key[to_store] = 0;
1361 *msg_cur += to_read;
1362 }
1363 else if (st->table->type == SMP_T_SINT) {
1364 unsigned int netinteger;
1365
Willy Tarreau1e82a142019-01-29 11:08:06 +01001366 if (*msg_cur + sizeof(netinteger) > msg_end)
1367 goto malformed_free_newts;
1368
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001369 memcpy(&netinteger, *msg_cur, sizeof(netinteger));
1370 netinteger = ntohl(netinteger);
1371 memcpy(newts->key.key, &netinteger, sizeof(netinteger));
1372 *msg_cur += sizeof(netinteger);
1373 }
1374 else {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001375 if (*msg_cur + st->table->key_size > msg_end)
1376 goto malformed_free_newts;
1377
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001378 memcpy(newts->key.key, *msg_cur, st->table->key_size);
1379 *msg_cur += st->table->key_size;
1380 }
1381
1382 /* lookup for existing entry */
1383 ts = stktable_set_entry(st->table, newts);
1384 if (ts != newts) {
1385 stksess_free(st->table, newts);
1386 newts = NULL;
1387 }
1388
1389 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
1390
1391 for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
Willy Tarreau1e82a142019-01-29 11:08:06 +01001392 uint64_t decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001393
1394 if (!((1 << data_type) & st->remote_data))
1395 continue;
1396
Willy Tarreau1e82a142019-01-29 11:08:06 +01001397 decoded_int = intdecode(msg_cur, msg_end);
1398 if (!*msg_cur)
1399 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001400
Willy Tarreau1e82a142019-01-29 11:08:06 +01001401 switch (stktable_data_types[data_type].std_type) {
1402 case STD_T_SINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001403 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1404 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001405 stktable_data_cast(data_ptr, std_t_sint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001406 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001407
Willy Tarreau1e82a142019-01-29 11:08:06 +01001408 case STD_T_UINT:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001409 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1410 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001411 stktable_data_cast(data_ptr, std_t_uint) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001412 break;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001413
Willy Tarreau1e82a142019-01-29 11:08:06 +01001414 case STD_T_ULL:
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001415 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1416 if (data_ptr)
Willy Tarreau1e82a142019-01-29 11:08:06 +01001417 stktable_data_cast(data_ptr, std_t_ull) = decoded_int;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001418 break;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001419
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001420 case STD_T_FRQP: {
1421 struct freq_ctr_period data;
1422
1423 /* First bit is reserved for the freq_ctr_period lock
1424 Note: here we're still protected by the stksess lock
1425 so we don't need to update the update the freq_ctr_period
1426 using its internal lock */
1427
Willy Tarreau1e82a142019-01-29 11:08:06 +01001428 data.curr_tick = tick_add(now_ms, -decoded_int) & ~0x1;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001429 data.curr_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001430 if (!*msg_cur)
1431 goto malformed_unlock;
1432
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001433 data.prev_ctr = intdecode(msg_cur, msg_end);
Willy Tarreau1e82a142019-01-29 11:08:06 +01001434 if (!*msg_cur)
1435 goto malformed_unlock;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001436
1437 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1438 if (data_ptr)
1439 stktable_data_cast(data_ptr, std_t_frqp) = data;
1440 break;
1441 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001442 case STD_T_DICT: {
1443 struct buffer *chunk;
1444 size_t data_len, value_len;
1445 unsigned int id;
1446 struct dict_entry *de;
1447 struct dcache *dc;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001448 char *end;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001449
1450 data_len = decoded_int;
1451 if (*msg_cur + data_len > msg_end)
1452 goto malformed_unlock;
1453
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001454 /* Compute the end of the current data, <msg_end> being at the end of
1455 * the entire message.
1456 */
1457 end = *msg_cur + data_len;
1458 id = intdecode(msg_cur, end);
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001459 if (!*msg_cur || !id)
1460 goto malformed_unlock;
1461
1462 dc = p->dcache;
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001463 if (*msg_cur == end) {
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001464 /* Dictionary entry key without value. */
1465 if (id > dc->max_entries)
1466 break;
1467 /* IDs sent over the network are numbered from 1. */
1468 de = dc->rx[id - 1].de;
1469 }
1470 else {
1471 chunk = get_trash_chunk();
Frédéric Lécaille344e9482019-06-05 10:20:09 +02001472 value_len = intdecode(msg_cur, end);
1473 if (!*msg_cur || *msg_cur + value_len > end ||
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001474 unlikely(value_len + 1 >= chunk->size))
1475 goto malformed_unlock;
1476
1477 chunk_memcpy(chunk, *msg_cur, value_len);
1478 chunk->area[chunk->data] = '\0';
Frédéric Lécaille56aec0d2019-06-06 14:14:15 +02001479 *msg_cur += value_len;
1480
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02001481 de = dict_insert(&server_name_dict, chunk->area);
1482 dc->rx[id - 1].de = de;
1483 }
1484 if (de) {
1485 data_ptr = stktable_data_ptr(st->table, ts, data_type);
1486 if (data_ptr)
1487 stktable_data_cast(data_ptr, std_t_dict) = de;
1488 }
1489 break;
1490 }
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001491 }
1492 }
1493 /* Force new expiration */
1494 ts->expire = tick_add(now_ms, expire);
1495
1496 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1497 stktable_touch_remote(st->table, ts, 1);
1498 return 1;
1499
1500 ignore_msg:
1501 /* skip consumed message */
1502 co_skip(si_oc(si), totl);
1503 return 0;
Willy Tarreau1e82a142019-01-29 11:08:06 +01001504
1505 malformed_unlock:
1506 /* malformed message */
1507 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1508 stktable_touch_remote(st->table, ts, 1);
1509 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1510 return 0;
1511
1512 malformed_free_newts:
1513 /* malformed message */
1514 stksess_free(st->table, newts);
1515 malformed_exit:
1516 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1517 return 0;
Frédéric Lécaille168a34b2019-01-23 11:16:57 +01001518}
1519
Frédéric Lécaille87f554c2019-01-22 17:26:50 +01001520/*
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001521 * Function used to parse a stick-table update acknowledgement message after it
1522 * has been received by <p> peer with <msg_cur> as address of the pointer to the position in the
1523 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1524 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1525 * was encountered.
1526 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1527 */
1528static inline int peer_treat_ackmsg(struct appctx *appctx, struct peer *p,
1529 char **msg_cur, char *msg_end)
1530{
1531 /* ack message */
1532 uint32_t table_id ;
1533 uint32_t update;
1534 struct shared_table *st;
1535
1536 table_id = intdecode(msg_cur, msg_end);
1537 if (!*msg_cur || (*msg_cur + sizeof(update) > msg_end)) {
1538 /* malformed message */
1539 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1540 return 0;
1541 }
1542
1543 memcpy(&update, *msg_cur, sizeof(update));
1544 update = ntohl(update);
1545
1546 for (st = p->tables; st; st = st->next) {
1547 if (st->local_id == table_id) {
1548 st->update = update;
1549 break;
1550 }
1551 }
1552
1553 return 1;
1554}
1555
1556/*
1557 * Function used to parse a stick-table switch message after it has been received
1558 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1559 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1560 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1561 * was encountered.
1562 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1563 */
1564static inline int peer_treat_switchmsg(struct appctx *appctx, struct peer *p,
1565 char **msg_cur, char *msg_end)
1566{
1567 struct shared_table *st;
1568 int table_id;
1569
1570 table_id = intdecode(msg_cur, msg_end);
1571 if (!*msg_cur) {
1572 /* malformed message */
1573 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1574 return 0;
1575 }
1576
1577 p->remote_table = NULL;
1578 for (st = p->tables; st; st = st->next) {
1579 if (st->remote_id == table_id) {
1580 p->remote_table = st;
1581 break;
1582 }
1583 }
1584
1585 return 1;
1586}
1587
1588/*
1589 * Function used to parse a stick-table definition message after it has been received
1590 * by <p> peer with <msg_cur> as address of the pointer to the position in the
1591 * receipt buffer with <msg_end> being the position of the end of the stick-table message.
1592 * Update <msg_curr> accordingly to the peer protocol specs if no peer protocol error
1593 * was encountered.
1594 * <totl> is the length of the stick-table update message computed upon receipt.
1595 * Return 1 if succeeded, 0 if not with the appctx state st0 set to PEER_SESS_ST_ERRPROTO.
1596 */
1597static inline int peer_treat_definemsg(struct appctx *appctx, struct peer *p,
1598 char **msg_cur, char *msg_end, int totl)
1599{
1600 struct stream_interface *si = appctx->owner;
1601 int table_id_len;
1602 struct shared_table *st;
1603 int table_type;
1604 int table_keylen;
1605 int table_id;
1606 uint64_t table_data;
1607
1608 table_id = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001609 if (!*msg_cur)
1610 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001611
1612 table_id_len = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001613 if (!*msg_cur)
1614 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001615
1616 p->remote_table = NULL;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001617 if (!table_id_len || (*msg_cur + table_id_len) >= msg_end)
1618 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001619
1620 for (st = p->tables; st; st = st->next) {
1621 /* Reset IDs */
1622 if (st->remote_id == table_id)
1623 st->remote_id = 0;
1624
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001625 if (!p->remote_table && (table_id_len == strlen(st->table->nid)) &&
1626 (memcmp(st->table->nid, *msg_cur, table_id_len) == 0))
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001627 p->remote_table = st;
1628 }
1629
1630 if (!p->remote_table)
1631 goto ignore_msg;
1632
1633 *msg_cur += table_id_len;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001634 if (*msg_cur >= msg_end)
1635 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001636
1637 table_type = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001638 if (!*msg_cur)
1639 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001640
1641 table_keylen = intdecode(msg_cur, msg_end);
Willy Tarreau6f731f32019-01-29 11:11:23 +01001642 if (!*msg_cur)
1643 goto malformed_exit;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001644
1645 table_data = 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 if (p->remote_table->table->type != table_type
1650 || p->remote_table->table->key_size != table_keylen) {
1651 p->remote_table = NULL;
1652 goto ignore_msg;
1653 }
1654
1655 p->remote_table->remote_data = table_data;
1656 p->remote_table->remote_id = table_id;
1657 return 1;
1658
1659 ignore_msg:
1660 co_skip(si_oc(si), totl);
1661 return 0;
Willy Tarreau6f731f32019-01-29 11:11:23 +01001662
1663 malformed_exit:
1664 /* malformed message */
1665 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1666 return 0;
Frédéric Lécailled27b0942019-01-23 17:31:37 +01001667}
1668
1669/*
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001670 * Receive a stick-table message.
1671 * Returns 1 if there was no error, if not, returns 0 if not enough data were available,
1672 * -1 if there was an error updating the appctx state st0 accordingly.
1673 */
1674static inline int peer_recv_msg(struct appctx *appctx, char *msg_head, size_t msg_head_sz,
1675 uint32_t *msg_len, int *totl)
1676{
1677 int reql;
1678 struct stream_interface *si = appctx->owner;
1679
1680 reql = co_getblk(si_oc(si), msg_head, 2 * sizeof(char), *totl);
1681 if (reql <= 0) /* closed or EOL not found */
1682 goto incomplete;
1683
1684 *totl += reql;
1685
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001686 if (!(msg_head[1] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001687 return 1;
1688
1689 /* Read and Decode message length */
1690 reql = co_getblk(si_oc(si), &msg_head[2], sizeof(char), *totl);
1691 if (reql <= 0) /* closed */
1692 goto incomplete;
1693
1694 *totl += reql;
1695
Frédéric Lécaille32b55732019-06-03 18:29:51 +02001696 if ((unsigned int)msg_head[2] < PEER_ENC_2BYTES_MIN) {
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001697 *msg_len = msg_head[2];
1698 }
1699 else {
1700 int i;
1701 char *cur;
1702 char *end;
1703
1704 for (i = 3 ; i < msg_head_sz ; i++) {
1705 reql = co_getblk(si_oc(si), &msg_head[i], sizeof(char), *totl);
1706 if (reql <= 0) /* closed */
1707 goto incomplete;
1708
1709 *totl += reql;
1710
Frédéric Lécaille36fb77e2019-06-04 08:28:19 +02001711 if (!(msg_head[i] & PEER_MSG_STKT_BIT_MASK))
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001712 break;
1713 }
1714
1715 if (i == msg_head_sz) {
1716 /* malformed message */
1717 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1718 return -1;
1719 }
1720 end = msg_head + msg_head_sz;
1721 cur = &msg_head[2];
1722 *msg_len = intdecode(&cur, end);
1723 if (!cur) {
1724 /* malformed message */
1725 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1726 return -1;
1727 }
1728 }
1729
1730 /* Read message content */
1731 if (*msg_len) {
1732 if (*msg_len > trash.size) {
1733 /* Status code is not success, abort */
1734 appctx->st0 = PEER_SESS_ST_ERRSIZE;
1735 return -1;
1736 }
1737
1738 reql = co_getblk(si_oc(si), trash.area, *msg_len, *totl);
1739 if (reql <= 0) /* closed */
1740 goto incomplete;
1741 *totl += reql;
1742 }
1743
1744 return 1;
1745
1746 incomplete:
1747 if (reql < 0) {
1748 /* there was an error */
1749 appctx->st0 = PEER_SESS_ST_END;
1750 return -1;
1751 }
1752
1753 return 0;
1754}
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001755
1756/*
1757 * Treat the awaited message with <msg_head> as header.*
1758 * Return 1 if succeeded, 0 if not.
1759 */
1760static inline int peer_treat_awaited_msg(struct appctx *appctx, struct peer *peer, unsigned char *msg_head,
1761 char **msg_cur, char *msg_end, int msg_len, int totl)
1762{
1763 struct stream_interface *si = appctx->owner;
1764 struct stream *s = si_strm(si);
1765 struct peers *peers = strm_fe(s)->parent;
1766
1767 if (msg_head[0] == PEER_MSG_CLASS_CONTROL) {
1768 if (msg_head[1] == PEER_MSG_CTRL_RESYNCREQ) {
1769 struct shared_table *st;
1770 /* Reset message: remote need resync */
1771
1772 /* prepare tables fot a global push */
1773 for (st = peer->tables; st; st = st->next) {
1774 st->teaching_origin = st->last_pushed = st->table->update;
1775 st->flags = 0;
1776 }
1777
1778 /* reset teaching flags to 0 */
1779 peer->flags &= PEER_TEACH_RESET;
1780
1781 /* flag to start to teach lesson */
1782 peer->flags |= PEER_F_TEACH_PROCESS;
1783 }
1784 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCFINISHED) {
1785 if (peer->flags & PEER_F_LEARN_ASSIGN) {
1786 peer->flags &= ~PEER_F_LEARN_ASSIGN;
1787 peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
1788 peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
1789 }
1790 peer->confirm++;
1791 }
1792 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCPARTIAL) {
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
1797 peer->flags |= PEER_F_LEARN_NOTUP2DATE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001798 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001799 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
1800 }
1801 peer->confirm++;
1802 }
1803 else if (msg_head[1] == PEER_MSG_CTRL_RESYNCCONFIRM) {
1804 struct shared_table *st;
1805
1806 /* If stopping state */
1807 if (stopping) {
1808 /* Close session, push resync no more needed */
1809 peer->flags |= PEER_F_TEACH_COMPLETE;
1810 appctx->st0 = PEER_SESS_ST_END;
1811 return 0;
1812 }
1813 for (st = peer->tables; st; st = st->next) {
1814 st->update = st->last_pushed = st->teaching_origin;
1815 st->flags = 0;
1816 }
1817
1818 /* reset teaching flags to 0 */
1819 peer->flags &= PEER_TEACH_RESET;
1820 }
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001821 else if (msg_head[1] == PEER_MSG_CTRL_HEARTBEAT) {
Frédéric Lécaille54bff832019-03-26 10:25:20 +01001822 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille645635d2019-02-11 17:49:39 +01001823 }
Frédéric Lécaille444243c2019-01-24 15:40:11 +01001824 }
1825 else if (msg_head[0] == PEER_MSG_CLASS_STICKTABLE) {
1826 if (msg_head[1] == PEER_MSG_STKT_DEFINE) {
1827 if (!peer_treat_definemsg(appctx, peer, msg_cur, msg_end, totl))
1828 return 0;
1829 }
1830 else if (msg_head[1] == PEER_MSG_STKT_SWITCH) {
1831 if (!peer_treat_switchmsg(appctx, peer, msg_cur, msg_end))
1832 return 0;
1833 }
1834 else if (msg_head[1] == PEER_MSG_STKT_UPDATE ||
1835 msg_head[1] == PEER_MSG_STKT_INCUPDATE ||
1836 msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED ||
1837 msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED) {
1838 int update, expire;
1839
1840 update = msg_head[1] == PEER_MSG_STKT_UPDATE || msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED;
1841 expire = msg_head[1] == PEER_MSG_STKT_UPDATE_TIMED || msg_head[1] == PEER_MSG_STKT_INCUPDATE_TIMED;
1842 if (!peer_treat_updatemsg(appctx, peer, update, expire,
1843 msg_cur, msg_end, msg_len, totl))
1844 return 0;
1845
1846 }
1847 else if (msg_head[1] == PEER_MSG_STKT_ACK) {
1848 if (!peer_treat_ackmsg(appctx, peer, msg_cur, msg_end))
1849 return 0;
1850 }
1851 }
1852 else if (msg_head[0] == PEER_MSG_CLASS_RESERVED) {
1853 appctx->st0 = PEER_SESS_ST_ERRPROTO;
1854 return 0;
1855 }
1856
1857 return 1;
1858}
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01001859
1860
1861/*
1862 * Send any message to <peer> peer.
1863 * Returns 1 if succeeded, or -1 or 0 if failed.
1864 * -1 means an internal error occured, 0 is for a peer protocol error leading
1865 * to a peer state change (from the peer I/O handler point of view).
1866 */
1867static inline int peer_send_msgs(struct appctx *appctx, struct peer *peer)
1868{
1869 int repl;
1870 struct stream_interface *si = appctx->owner;
1871 struct stream *s = si_strm(si);
1872 struct peers *peers = strm_fe(s)->parent;
1873
1874 /* Need to request a resync */
1875 if ((peer->flags & PEER_F_LEARN_ASSIGN) &&
1876 (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
1877 !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
1878
1879 repl = peer_send_resync_reqmsg(appctx);
1880 if (repl <= 0)
1881 return repl;
1882
1883 peers->flags |= PEERS_F_RESYNC_PROCESS;
1884 }
1885
1886 /* Nothing to read, now we start to write */
1887 if (peer->tables) {
1888 struct shared_table *st;
1889 struct shared_table *last_local_table;
1890
1891 last_local_table = peer->last_local_table;
1892 if (!last_local_table)
1893 last_local_table = peer->tables;
1894 st = last_local_table->next;
1895
1896 while (1) {
1897 if (!st)
1898 st = peer->tables;
1899
1900 /* It remains some updates to ack */
1901 if (st->last_get != st->last_acked) {
1902 repl = peer_send_ackmsg(st, appctx);
1903 if (repl <= 0)
1904 return repl;
1905
1906 st->last_acked = st->last_get;
1907 }
1908
1909 if (!(peer->flags & PEER_F_TEACH_PROCESS)) {
1910 HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
1911 if (!(peer->flags & PEER_F_LEARN_ASSIGN) &&
1912 ((int)(st->last_pushed - st->table->localupdate) < 0)) {
1913
1914 repl = peer_send_teach_process_msgs(appctx, peer, st);
1915 if (repl <= 0) {
1916 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1917 return repl;
1918 }
1919 }
1920 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
1921 }
1922 else {
1923 if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
1924 repl = peer_send_teach_stage1_msgs(appctx, peer, st);
1925 if (repl <= 0)
1926 return repl;
1927 }
1928
1929 if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
1930 repl = peer_send_teach_stage2_msgs(appctx, peer, st);
1931 if (repl <= 0)
1932 return repl;
1933 }
1934 }
1935
1936 if (st == last_local_table)
1937 break;
1938 st = st->next;
1939 }
1940 }
1941
1942 if ((peer->flags & PEER_F_TEACH_PROCESS) && !(peer->flags & PEER_F_TEACH_FINISHED)) {
1943 repl = peer_send_resync_finishedmsg(appctx, peer);
1944 if (repl <= 0)
1945 return repl;
1946
1947 /* flag finished message sent */
1948 peer->flags |= PEER_F_TEACH_FINISHED;
1949 }
1950
1951 /* Confirm finished or partial messages */
1952 while (peer->confirm) {
1953 repl = peer_send_resync_confirmsg(appctx);
1954 if (repl <= 0)
1955 return repl;
1956
1957 peer->confirm--;
1958 }
1959
1960 return 1;
1961}
1962
Frédéric Lécaille95203f22019-01-23 19:38:11 +01001963/*
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01001964 * Read and parse a first line of a "hello" peer protocol message.
1965 * Returns 0 if could not read a line, -1 if there was a read error or
1966 * the line is malformed, 1 if succeeded.
1967 */
1968static inline int peer_getline_version(struct appctx *appctx,
1969 unsigned int *maj_ver, unsigned int *min_ver)
1970{
1971 int reql;
1972
1973 reql = peer_getline(appctx);
1974 if (!reql)
1975 return 0;
1976
1977 if (reql < 0)
1978 return -1;
1979
1980 /* test protocol */
1981 if (strncmp(PEER_SESSION_PROTO_NAME " ", trash.area, proto_len + 1) != 0) {
1982 appctx->st0 = PEER_SESS_ST_EXIT;
1983 appctx->st1 = PEER_SESS_SC_ERRPROTO;
1984 return -1;
1985 }
1986 if (peer_get_version(trash.area + proto_len + 1, maj_ver, min_ver) == -1 ||
1987 *maj_ver != PEER_MAJOR_VER || *min_ver > PEER_MINOR_VER) {
1988 appctx->st0 = PEER_SESS_ST_EXIT;
1989 appctx->st1 = PEER_SESS_SC_ERRVERSION;
1990 return -1;
1991 }
1992
1993 return 1;
1994}
1995
1996/*
1997 * Read and parse a second line of a "hello" peer protocol message.
1998 * Returns 0 if could not read a line, -1 if there was a read error or
1999 * the line is malformed, 1 if succeeded.
2000 */
2001static inline int peer_getline_host(struct appctx *appctx)
2002{
2003 int reql;
2004
2005 reql = peer_getline(appctx);
2006 if (!reql)
2007 return 0;
2008
2009 if (reql < 0)
2010 return -1;
2011
2012 /* test hostname match */
2013 if (strcmp(localpeer, trash.area) != 0) {
2014 appctx->st0 = PEER_SESS_ST_EXIT;
2015 appctx->st1 = PEER_SESS_SC_ERRHOST;
2016 return -1;
2017 }
2018
2019 return 1;
2020}
2021
2022/*
2023 * Read and parse a last line of a "hello" peer protocol message.
2024 * Returns 0 if could not read a character, -1 if there was a read error or
2025 * the line is malformed, 1 if succeeded.
2026 * Set <curpeer> accordingly (the remote peer sending the "hello" message).
2027 */
2028static inline int peer_getline_last(struct appctx *appctx, struct peer **curpeer)
2029{
2030 char *p;
2031 int reql;
2032 struct peer *peer;
2033 struct stream_interface *si = appctx->owner;
2034 struct stream *s = si_strm(si);
2035 struct peers *peers = strm_fe(s)->parent;
2036
2037 reql = peer_getline(appctx);
2038 if (!reql)
2039 return 0;
2040
2041 if (reql < 0)
2042 return -1;
2043
2044 /* parse line "<peer name> <pid> <relative_pid>" */
2045 p = strchr(trash.area, ' ');
2046 if (!p) {
2047 appctx->st0 = PEER_SESS_ST_EXIT;
2048 appctx->st1 = PEER_SESS_SC_ERRPROTO;
2049 return -1;
2050 }
2051 *p = 0;
2052
2053 /* lookup known peer */
2054 for (peer = peers->remote; peer; peer = peer->next) {
2055 if (strcmp(peer->id, trash.area) == 0)
2056 break;
2057 }
2058
2059 /* if unknown peer */
2060 if (!peer) {
2061 appctx->st0 = PEER_SESS_ST_EXIT;
2062 appctx->st1 = PEER_SESS_SC_ERRPEER;
2063 return -1;
2064 }
2065 *curpeer = peer;
2066
2067 return 1;
2068}
2069
2070/*
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002071 * Init <peer> peer after having accepted it at peer protocol level.
2072 */
2073static inline void init_accepted_peer(struct peer *peer, struct peers *peers)
2074{
2075 struct shared_table *st;
2076
2077 /* Register status code */
2078 peer->statuscode = PEER_SESS_SC_SUCCESSCODE;
2079
2080 /* Awake main task */
2081 task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
2082
2083 /* Init confirm counter */
2084 peer->confirm = 0;
2085
2086 /* Init cursors */
2087 for (st = peer->tables; st ; st = st->next) {
2088 st->last_get = st->last_acked = 0;
2089 st->teaching_origin = st->last_pushed = st->update;
2090 }
2091
2092 /* reset teaching and learning flags to 0 */
2093 peer->flags &= PEER_TEACH_RESET;
2094 peer->flags &= PEER_LEARN_RESET;
2095
2096 /* if current peer is local */
2097 if (peer->local) {
2098 /* if current host need resyncfrom local and no process assined */
2099 if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
2100 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2101 /* assign local peer for a lesson, consider lesson already requested */
2102 peer->flags |= PEER_F_LEARN_ASSIGN;
2103 peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
2104 }
2105
2106 }
2107 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2108 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2109 /* assign peer for a lesson */
2110 peer->flags |= PEER_F_LEARN_ASSIGN;
2111 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2112 }
2113}
2114
2115/*
2116 * Init <peer> peer after having connected it at peer protocol level.
2117 */
2118static inline void init_connected_peer(struct peer *peer, struct peers *peers)
2119{
2120 struct shared_table *st;
2121
2122 /* Init cursors */
2123 for (st = peer->tables; st ; st = st->next) {
2124 st->last_get = st->last_acked = 0;
2125 st->teaching_origin = st->last_pushed = st->update;
2126 }
2127
2128 /* Init confirm counter */
2129 peer->confirm = 0;
2130
2131 /* reset teaching and learning flags to 0 */
2132 peer->flags &= PEER_TEACH_RESET;
2133 peer->flags &= PEER_LEARN_RESET;
2134
2135 /* If current peer is local */
2136 if (peer->local) {
2137 /* flag to start to teach lesson */
2138 peer->flags |= PEER_F_TEACH_PROCESS;
2139 }
2140 else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
2141 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
2142 /* If peer is remote and resync from remote is needed,
2143 and no peer currently assigned */
2144
2145 /* assign peer for a lesson */
2146 peer->flags |= PEER_F_LEARN_ASSIGN;
2147 peers->flags |= PEERS_F_RESYNC_ASSIGN;
2148 }
2149}
2150
2151/*
Emeric Brun2b920a12010-09-23 18:30:22 +02002152 * IO Handler to handle message exchance with a peer
2153 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02002154static void peer_io_handler(struct appctx *appctx)
Emeric Brun2b920a12010-09-23 18:30:22 +02002155{
Willy Tarreau00a37f02015-04-13 12:05:19 +02002156 struct stream_interface *si = appctx->owner;
Willy Tarreau87b09662015-04-03 00:22:06 +02002157 struct stream *s = si_strm(si);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002158 struct peers *curpeers = strm_fe(s)->parent;
Emeric Brun80527f52017-06-19 17:46:37 +02002159 struct peer *curpeer = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002160 int reql = 0;
2161 int repl = 0;
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002162 unsigned int maj_ver, min_ver;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002163 int prev_state;
Emeric Brun2b920a12010-09-23 18:30:22 +02002164
Joseph Herlant82b2f542018-11-15 12:19:14 -08002165 /* Check if the input buffer is available. */
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002166 if (si_ic(si)->buf.size == 0) {
2167 si_rx_room_blk(si);
2168 goto out;
2169 }
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002170
Emeric Brun2b920a12010-09-23 18:30:22 +02002171 while (1) {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002172 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002173switchstate:
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002174 maj_ver = min_ver = (unsigned int)-1;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002175 switch(appctx->st0) {
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002176 case PEER_SESS_ST_ACCEPT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002177 prev_state = appctx->st0;
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002178 appctx->ctx.peers.ptr = NULL;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002179 appctx->st0 = PEER_SESS_ST_GETVERSION;
Emeric Brun2b920a12010-09-23 18:30:22 +02002180 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002181 case PEER_SESS_ST_GETVERSION:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002182 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002183 reql = peer_getline_version(appctx, &maj_ver, &min_ver);
2184 if (reql <= 0) {
2185 if (!reql)
2186 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002187 goto switchstate;
2188 }
2189
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002190 appctx->st0 = PEER_SESS_ST_GETHOST;
Emeric Brun2b920a12010-09-23 18:30:22 +02002191 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002192 case PEER_SESS_ST_GETHOST:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002193 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002194 reql = peer_getline_host(appctx);
2195 if (reql <= 0) {
2196 if (!reql)
2197 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002198 goto switchstate;
2199 }
2200
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002201 appctx->st0 = PEER_SESS_ST_GETPEER;
Emeric Brun2b920a12010-09-23 18:30:22 +02002202 /* fall through */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002203 case PEER_SESS_ST_GETPEER: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002204 prev_state = appctx->st0;
Frédéric Lécaille3f0fb9d2019-01-25 08:30:29 +01002205 reql = peer_getline_last(appctx, &curpeer);
2206 if (reql <= 0) {
2207 if (!reql)
2208 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002209 goto switchstate;
2210 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002211
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002212 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002213 if (curpeer->appctx && curpeer->appctx != appctx) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002214 if (curpeer->local) {
2215 /* Local connection, reply a retry */
2216 appctx->st0 = PEER_SESS_ST_EXIT;
2217 appctx->st1 = PEER_SESS_SC_TRYAGAIN;
2218 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002219 }
Emeric Brun80527f52017-06-19 17:46:37 +02002220
2221 /* we're killing a connection, we must apply a random delay before
2222 * retrying otherwise the other end will do the same and we can loop
2223 * for a while.
2224 */
2225 curpeer->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002226 peer_session_forceshutdown(curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002227 }
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002228 if (maj_ver != (unsigned int)-1 && min_ver != (unsigned int)-1) {
2229 if (min_ver == PEER_DWNGRD_MINOR_VER) {
2230 curpeer->flags |= PEER_F_DWNGRD;
2231 }
2232 else {
2233 curpeer->flags &= ~PEER_F_DWNGRD;
2234 }
2235 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002236 curpeer->appctx = appctx;
2237 appctx->ctx.peers.ptr = curpeer;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002238 appctx->st0 = PEER_SESS_ST_SENDSUCCESS;
Olivier Houcharded879892019-03-08 18:53:43 +01002239 _HA_ATOMIC_ADD(&active_peers, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02002240 /* fall through */
2241 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002242 case PEER_SESS_ST_SENDSUCCESS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002243 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002244 if (!curpeer) {
2245 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002246 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002247 if (curpeer->appctx != appctx) {
2248 appctx->st0 = PEER_SESS_ST_END;
2249 goto switchstate;
2250 }
2251 }
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002252
2253 repl = peer_send_status_successmsg(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002254 if (repl <= 0) {
2255 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002256 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002257 goto switchstate;
2258 }
2259
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002260 init_accepted_peer(curpeer, curpeers);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002261
Emeric Brun2b920a12010-09-23 18:30:22 +02002262 /* switch to waiting message state */
Olivier Houcharded879892019-03-08 18:53:43 +01002263 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002264 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002265 goto switchstate;
2266 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002267 case PEER_SESS_ST_CONNECT: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002268 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002269 if (!curpeer) {
2270 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002271 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002272 if (curpeer->appctx != appctx) {
2273 appctx->st0 = PEER_SESS_ST_END;
2274 goto switchstate;
2275 }
2276 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002277
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002278 repl = peer_send_hellomsg(appctx, curpeer);
Emeric Brun2b920a12010-09-23 18:30:22 +02002279 if (repl <= 0) {
2280 if (repl == -1)
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002281 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002282 goto switchstate;
2283 }
2284
2285 /* switch to the waiting statuscode state */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002286 appctx->st0 = PEER_SESS_ST_GETSTATUS;
Emeric Brun2b920a12010-09-23 18:30:22 +02002287 /* fall through */
2288 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002289 case PEER_SESS_ST_GETSTATUS: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002290 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002291 if (!curpeer) {
2292 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002293 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002294 if (curpeer->appctx != appctx) {
2295 appctx->st0 = PEER_SESS_ST_END;
2296 goto switchstate;
2297 }
2298 }
2299
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002300 if (si_ic(si)->flags & CF_WRITE_PARTIAL)
Emeric Brunb3971ab2015-05-12 18:49:09 +02002301 curpeer->statuscode = PEER_SESS_SC_CONNECTEDCODE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002302
Frédéric Lécaillece025572019-01-21 13:38:06 +01002303 reql = peer_getline(appctx);
2304 if (!reql)
2305 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002306
Frédéric Lécaillece025572019-01-21 13:38:06 +01002307 if (reql < 0)
2308 goto switchstate;
Emeric Brun2b920a12010-09-23 18:30:22 +02002309
2310 /* Register status code */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002311 curpeer->statuscode = atoi(trash.area);
Emeric Brun2b920a12010-09-23 18:30:22 +02002312
2313 /* Awake main task */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002314 task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
Emeric Brun2b920a12010-09-23 18:30:22 +02002315
2316 /* If status code is success */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002317 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Frédéric Lécaille4b2fd9b2019-01-25 08:58:41 +01002318 init_connected_peer(curpeer, curpeers);
Emeric Brun2b920a12010-09-23 18:30:22 +02002319 }
2320 else {
Frédéric Lécaille523cc9e2016-10-12 17:30:30 +02002321 if (curpeer->statuscode == PEER_SESS_SC_ERRVERSION)
2322 curpeer->flags |= PEER_F_DWNGRD;
Emeric Brun2b920a12010-09-23 18:30:22 +02002323 /* Status code is not success, abort */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002324 appctx->st0 = PEER_SESS_ST_END;
Emeric Brun2b920a12010-09-23 18:30:22 +02002325 goto switchstate;
2326 }
Olivier Houcharded879892019-03-08 18:53:43 +01002327 _HA_ATOMIC_ADD(&connected_peers, 1);
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002328 appctx->st0 = PEER_SESS_ST_WAITMSG;
Emeric Brun2b920a12010-09-23 18:30:22 +02002329 /* fall through */
2330 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002331 case PEER_SESS_ST_WAITMSG: {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002332 uint32_t msg_len = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002333 char *msg_cur = trash.area;
2334 char *msg_end = trash.area;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002335 unsigned char msg_head[7];
Emeric Brun2b920a12010-09-23 18:30:22 +02002336 int totl = 0;
2337
Willy Tarreau2d372c22018-11-05 17:12:27 +01002338 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002339 if (!curpeer) {
2340 curpeer = appctx->ctx.peers.ptr;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002341 HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002342 if (curpeer->appctx != appctx) {
2343 appctx->st0 = PEER_SESS_ST_END;
2344 goto switchstate;
2345 }
2346 }
2347
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002348 reql = peer_recv_msg(appctx, (char *)msg_head, sizeof msg_head, &msg_len, &totl);
2349 if (reql <= 0) {
2350 if (reql == -1)
2351 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002352 goto send_msgs;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002353 }
Willy Tarreau86a446e2013-11-25 23:02:37 +01002354
Frédéric Lécaille95203f22019-01-23 19:38:11 +01002355 msg_end += msg_len;
Frédéric Lécaille444243c2019-01-24 15:40:11 +01002356 if (!peer_treat_awaited_msg(appctx, curpeer, msg_head, &msg_cur, msg_end, msg_len, totl))
Emeric Brun2b920a12010-09-23 18:30:22 +02002357 goto switchstate;
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002358
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002359 curpeer->flags |= PEER_F_ALIVE;
2360
Emeric Brun2b920a12010-09-23 18:30:22 +02002361 /* skip consumed message */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002362 co_skip(si_oc(si), totl);
Emeric Brun2b920a12010-09-23 18:30:22 +02002363 /* loop on that state to peek next message */
Willy Tarreau72d6c162013-04-11 16:14:13 +02002364 goto switchstate;
2365
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002366send_msgs:
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002367 if (curpeer->flags & PEER_F_HEARTBEAT) {
2368 curpeer->flags &= ~PEER_F_HEARTBEAT;
2369 repl = peer_send_heartbeatmsg(appctx);
2370 if (repl <= 0) {
2371 if (repl == -1)
2372 goto out;
2373 goto switchstate;
2374 }
2375 }
Frédéric Lécaillebe825e52019-01-24 18:28:44 +01002376 /* we get here when a peer_recv_msg() returns 0 in reql */
Frédéric Lécaille25e1d5e2019-01-24 17:33:48 +01002377 repl = peer_send_msgs(appctx, curpeer);
2378 if (repl <= 0) {
2379 if (repl == -1)
2380 goto out;
2381 goto switchstate;
Emeric Brun597b26e2016-08-12 11:23:31 +02002382 }
2383
Emeric Brun2b920a12010-09-23 18:30:22 +02002384 /* noting more to do */
2385 goto out;
2386 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002387 case PEER_SESS_ST_EXIT:
Willy Tarreau2d372c22018-11-05 17:12:27 +01002388 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002389 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002390 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002391 if (peer_send_status_errormsg(appctx) == -1)
2392 goto out;
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002393 appctx->st0 = PEER_SESS_ST_END;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002394 goto switchstate;
2395 case PEER_SESS_ST_ERRSIZE: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002396 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002397 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002398 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002399 if (peer_send_error_size_limitmsg(appctx) == -1)
2400 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002401 appctx->st0 = PEER_SESS_ST_END;
2402 goto switchstate;
2403 }
2404 case PEER_SESS_ST_ERRPROTO: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002405 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002406 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002407 prev_state = appctx->st0;
Frédéric Lécaille7d0ceee2019-01-24 14:24:05 +01002408 if (peer_send_error_protomsg(appctx) == -1)
2409 goto out;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002410 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau2d372c22018-11-05 17:12:27 +01002411 prev_state = appctx->st0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002412 /* fall through */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002413 }
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002414 case PEER_SESS_ST_END: {
Willy Tarreau2d372c22018-11-05 17:12:27 +01002415 if (prev_state == PEER_SESS_ST_WAITMSG)
Olivier Houcharded879892019-03-08 18:53:43 +01002416 _HA_ATOMIC_SUB(&connected_peers, 1);
Willy Tarreau2d372c22018-11-05 17:12:27 +01002417 prev_state = appctx->st0;
Emeric Brun80527f52017-06-19 17:46:37 +02002418 if (curpeer) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002419 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002420 curpeer = NULL;
2421 }
Willy Tarreau73b013b2012-05-21 16:31:45 +02002422 si_shutw(si);
2423 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002424 si_ic(si)->flags |= CF_READ_NULL;
Willy Tarreau828824a2015-04-19 17:20:03 +02002425 goto out;
Emeric Brun2b920a12010-09-23 18:30:22 +02002426 }
2427 }
2428 }
2429out:
Willy Tarreau2bb4a962014-11-28 11:11:05 +01002430 si_oc(si)->flags |= CF_READ_DONTWAIT;
Emeric Brun80527f52017-06-19 17:46:37 +02002431
2432 if (curpeer)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002433 HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
Emeric Brun2b920a12010-09-23 18:30:22 +02002434 return;
2435}
2436
Willy Tarreau30576452015-04-13 13:50:30 +02002437static struct applet peer_applet = {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002438 .obj_type = OBJ_TYPE_APPLET,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002439 .name = "<PEER>", /* used for logging */
2440 .fct = peer_io_handler,
Aman Gupta9a13e842012-04-02 18:57:53 -07002441 .release = peer_session_release,
Willy Tarreaub24281b2011-02-13 13:16:36 +01002442};
Emeric Brun2b920a12010-09-23 18:30:22 +02002443
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002444
Emeric Brun2b920a12010-09-23 18:30:22 +02002445/*
2446 * Use this function to force a close of a peer session
2447 */
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002448static void peer_session_forceshutdown(struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002449{
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002450 struct appctx *appctx = peer->appctx;
2451
Frédéric Lécaille5df11902017-06-13 16:39:57 +02002452 /* Note that the peer sessions which have just been created
2453 * (->st0 == PEER_SESS_ST_CONNECT) must not
2454 * be shutdown, if not, the TCP session will never be closed
2455 * and stay in CLOSE_WAIT state after having been closed by
2456 * the remote side.
2457 */
2458 if (!appctx || appctx->st0 == PEER_SESS_ST_CONNECT)
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002459 return;
2460
Willy Tarreau81bc3b02016-10-31 17:37:39 +01002461 if (appctx->applet != &peer_applet)
2462 return;
2463
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002464 __peer_session_deinit(peer);
2465
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002466 appctx->st0 = PEER_SESS_ST_END;
Willy Tarreau78c0c502016-10-31 17:32:20 +01002467 appctx_wakeup(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002468}
2469
Willy Tarreau91d96282015-03-13 15:47:26 +01002470/* Pre-configures a peers frontend to accept incoming connections */
2471void peers_setup_frontend(struct proxy *fe)
2472{
2473 fe->last_change = now.tv_sec;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +02002474 fe->cap = PR_CAP_FE | PR_CAP_BE;
Willy Tarreau91d96282015-03-13 15:47:26 +01002475 fe->maxconn = 0;
2476 fe->conn_retries = CONN_RETRIES;
2477 fe->timeout.client = MS_TO_TICKS(5000);
Willy Tarreaud1d48d42015-03-13 16:15:46 +01002478 fe->accept = frontend_accept;
Willy Tarreauf87ab942015-03-13 15:55:16 +01002479 fe->default_target = &peer_applet.obj_type;
Willy Tarreau91d96282015-03-13 15:47:26 +01002480 fe->options2 |= PR_O2_INDEPSTR | PR_O2_SMARTCON | PR_O2_SMARTACC;
Willy Tarreau0fca4832015-05-01 19:12:05 +02002481 fe->bind_proc = 0; /* will be filled by users */
Willy Tarreau91d96282015-03-13 15:47:26 +01002482}
2483
Emeric Brun2b920a12010-09-23 18:30:22 +02002484/*
Willy Tarreaubd55e312010-11-11 10:55:09 +01002485 * Create a new peer session in assigned state (connect will start automatically)
Emeric Brun2b920a12010-09-23 18:30:22 +02002486 */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002487static struct appctx *peer_session_create(struct peers *peers, struct peer *peer)
Emeric Brun2b920a12010-09-23 18:30:22 +02002488{
Willy Tarreau04b92862017-09-15 11:01:04 +02002489 struct proxy *p = peers->peers_fe; /* attached frontend */
Willy Tarreau7b4b4992013-12-01 09:15:12 +01002490 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002491 struct session *sess;
Willy Tarreau87b09662015-04-03 00:22:06 +02002492 struct stream *s;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002493 struct connection *conn;
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002494 struct conn_stream *cs;
Emeric Brun2b920a12010-09-23 18:30:22 +02002495
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002496 peer->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002497 peer->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Emeric Brunb3971ab2015-05-12 18:49:09 +02002498 peer->statuscode = PEER_SESS_SC_CONNECTCODE;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002499 s = NULL;
2500
Emeric Brun1138fd02017-06-19 12:38:55 +02002501 appctx = appctx_new(&peer_applet, tid_bit);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002502 if (!appctx)
2503 goto out_close;
2504
2505 appctx->st0 = PEER_SESS_ST_CONNECT;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002506 appctx->ctx.peers.ptr = (void *)peer;
Willy Tarreaud990baf2015-04-05 00:32:03 +02002507
Willy Tarreau04b92862017-09-15 11:01:04 +02002508 sess = session_new(p, NULL, &appctx->obj_type);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002509 if (!sess) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002510 ha_alert("out of memory in peer_session_create().\n");
Willy Tarreaud990baf2015-04-05 00:32:03 +02002511 goto out_free_appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002512 }
2513
Willy Tarreau87787ac2017-08-28 16:22:54 +02002514 if ((s = stream_new(sess, &appctx->obj_type)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002515 ha_alert("Failed to initialize stream in peer_session_create().\n");
Willy Tarreau87787ac2017-08-28 16:22:54 +02002516 goto out_free_sess;
Willy Tarreau8baf9062015-04-05 00:46:36 +02002517 }
2518
Willy Tarreau342bfb12015-04-05 01:35:34 +02002519 /* The tasks below are normally what is supposed to be done by
2520 * fe->accept().
2521 */
Willy Tarreaue7dff022015-04-03 01:14:29 +02002522 s->flags = SF_ASSIGNED|SF_ADDR_SET;
Emeric Brun2b920a12010-09-23 18:30:22 +02002523
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002524 /* applet is waiting for data */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002525 si_cant_get(&s->si[0]);
Willy Tarreau6e2979c2015-04-27 13:21:15 +02002526 appctx_wakeup(appctx);
2527
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002528 /* initiate an outgoing connection */
Willy Tarreaudbd02672017-12-06 17:39:53 +01002529 s->si[1].flags |= SI_FL_NOLINGER;
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002530 si_set_state(&s->si[1], SI_ST_ASS);
Willy Tarreau3ed35ef2013-10-24 11:51:38 +02002531
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002532 /* automatically prepare the stream interface to connect to the
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002533 * pre-initialized connection in si->conn.
2534 */
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002535 if (unlikely((conn = conn_new()) == NULL))
Willy Tarreau8baf9062015-04-05 00:46:36 +02002536 goto out_free_strm;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002537
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002538 if (unlikely((cs = cs_new(conn)) == NULL))
2539 goto out_free_conn;
2540
Frédéric Lécaille1055e682018-04-26 14:35:21 +02002541 conn->target = s->target = peer_session_target(peer, s);
Willy Tarreaube373152018-09-06 11:45:30 +02002542 memcpy(&conn->addr.to, &peer->addr, sizeof(conn->addr.to));
2543
Frédéric Lécaille1055e682018-04-26 14:35:21 +02002544 conn_prepare(conn, peer->proto, peer_xprt(peer));
Olivier Houchardef60ff32019-01-29 19:00:33 +01002545 if (conn_install_mux(conn, &mux_pt_ops, cs, s->be, NULL) < 0)
2546 goto out_free_cs;
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002547 si_attach_cs(&s->si[1], cs);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +02002548
Emeric Brun2b920a12010-09-23 18:30:22 +02002549 s->do_log = NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002550 s->uniq_id = 0;
Emeric Brun2b920a12010-09-23 18:30:22 +02002551
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002552 s->res.flags |= CF_READ_DONTWAIT;
Willy Tarreau696a2912014-11-24 11:36:57 +01002553
Emeric Brunb3971ab2015-05-12 18:49:09 +02002554 peer->appctx = appctx;
Willy Tarreau87787ac2017-08-28 16:22:54 +02002555 task_wakeup(s->task, TASK_WOKEN_INIT);
Olivier Houcharded879892019-03-08 18:53:43 +01002556 _HA_ATOMIC_ADD(&active_peers, 1);
Willy Tarreau9df94c22016-10-31 18:42:52 +01002557 return appctx;
Emeric Brun2b920a12010-09-23 18:30:22 +02002558
2559 /* Error unrolling */
Olivier Houchardef60ff32019-01-29 19:00:33 +01002560out_free_cs:
2561 cs_free(cs);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002562 out_free_conn:
2563 conn_free(conn);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002564 out_free_strm:
Emeric Brun2b920a12010-09-23 18:30:22 +02002565 LIST_DEL(&s->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +01002566 pool_free(pool_head_stream, s);
Willy Tarreau15b5e142015-04-04 14:38:25 +02002567 out_free_sess:
Willy Tarreau11c36242015-04-04 15:54:03 +02002568 session_free(sess);
Willy Tarreaud990baf2015-04-05 00:32:03 +02002569 out_free_appctx:
2570 appctx_free(appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002571 out_close:
Willy Tarreaub21d08e2016-10-31 17:46:57 +01002572 return NULL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002573}
2574
2575/*
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002576 * Task processing function to manage re-connect, peer session
2577 * tasks wakeup on local update and heartbeat.
Emeric Brun2b920a12010-09-23 18:30:22 +02002578 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02002579static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
Emeric Brun2b920a12010-09-23 18:30:22 +02002580{
Olivier Houchard9f6af332018-05-25 14:04:04 +02002581 struct peers *peers = context;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002582 struct peer *ps;
2583 struct shared_table *st;
Emeric Brun2b920a12010-09-23 18:30:22 +02002584
2585 task->expire = TICK_ETERNITY;
2586
Emeric Brunb3971ab2015-05-12 18:49:09 +02002587 if (!peers->peers_fe) {
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002588 /* this one was never started, kill it */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002589 signal_unregister_handler(peers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002590 task_destroy(peers->sync_task);
Willy Tarreau37bb7be2015-09-21 15:24:58 +02002591 peers->sync_task = NULL;
Willy Tarreau46dc1ca2015-05-01 18:32:13 +02002592 return NULL;
2593 }
2594
Emeric Brun80527f52017-06-19 17:46:37 +02002595 /* Acquire lock for all peers of the section */
2596 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002597 HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002598
Emeric Brun2b920a12010-09-23 18:30:22 +02002599 if (!stopping) {
2600 /* Normal case (not soft stop)*/
Emeric Brunb3971ab2015-05-12 18:49:09 +02002601
2602 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL) &&
2603 (!nb_oldpids || tick_is_expired(peers->resync_timeout, now_ms)) &&
2604 !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002605 /* Resync from local peer needed
2606 no peer was assigned for the lesson
2607 and no old local peer found
2608 or resync timeout expire */
2609
2610 /* flag no more resync from local, to try resync from remotes */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002611 peers->flags |= PEERS_F_RESYNC_LOCAL;
Emeric Brun2b920a12010-09-23 18:30:22 +02002612
2613 /* reschedule a resync */
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002614 peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(PEER_RESYNC_TIMEOUT));
Emeric Brun2b920a12010-09-23 18:30:22 +02002615 }
2616
2617 /* For each session */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002618 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002619 /* For each remote peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002620 if (!ps->local) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002621 if (!ps->appctx) {
2622 /* no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002623 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002624 ((ps->statuscode == PEER_SESS_SC_CONNECTCODE ||
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002625 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002626 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002627 tick_is_expired(ps->reconnect, now_ms))) {
2628 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002629 * or previous peer connection established with success
2630 * or previous peer connection failed while connecting
Emeric Brun2b920a12010-09-23 18:30:22 +02002631 * and reconnection timer is expired */
2632
2633 /* retry a connect */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002634 ps->appctx = peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002635 }
Willy Tarreaub4e34da2015-05-20 10:39:04 +02002636 else if (!tick_is_expired(ps->reconnect, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002637 /* If previous session failed during connection
2638 * but reconnection timer is not expired */
2639
2640 /* reschedule task for reconnect */
2641 task->expire = tick_first(task->expire, ps->reconnect);
2642 }
2643 /* else do nothing */
Willy Tarreau9df94c22016-10-31 18:42:52 +01002644 } /* !ps->appctx */
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002645 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002646 /* current peer connection is active and established */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002647 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2648 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
Emeric Brun2b920a12010-09-23 18:30:22 +02002649 !(ps->flags & PEER_F_LEARN_NOTUP2DATE)) {
2650 /* Resync from a remote is needed
2651 * and no peer was assigned for lesson
2652 * and current peer may be up2date */
2653
2654 /* assign peer for the lesson */
2655 ps->flags |= PEER_F_LEARN_ASSIGN;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002656 peers->flags |= PEERS_F_RESYNC_ASSIGN;
Emeric Brun2b920a12010-09-23 18:30:22 +02002657
Willy Tarreau9df94c22016-10-31 18:42:52 +01002658 /* wake up peer handler to handle a request of resync */
Willy Tarreaue5843b32015-04-27 18:40:14 +02002659 appctx_wakeup(ps->appctx);
Emeric Brun2b920a12010-09-23 18:30:22 +02002660 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002661 else {
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002662 int update_to_push = 0;
2663
Emeric Brunb3971ab2015-05-12 18:49:09 +02002664 /* Awake session if there is data to push */
2665 for (st = ps->tables; st ; st = st->next) {
2666 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002667 /* wake up the peer handler to push local updates */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002668 update_to_push = 1;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002669 /* There is no need to send a heartbeat message
2670 * when some updates must be pushed. The remote
2671 * peer will consider <ps> peer as alive when it will
2672 * receive these updates.
2673 */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002674 ps->flags &= ~PEER_F_HEARTBEAT;
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002675 /* Re-schedule another one later. */
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002676 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002677 /* We are going to send updates, let's ensure we will
2678 * come back to send heartbeat messages or to reconnect.
2679 */
2680 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002681 appctx_wakeup(ps->appctx);
2682 break;
2683 }
2684 }
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002685 /* When there are updates to send we do not reconnect
2686 * and do not send heartbeat message either.
2687 */
2688 if (!update_to_push) {
2689 if (tick_is_expired(ps->reconnect, now_ms)) {
2690 if (ps->flags & PEER_F_ALIVE) {
2691 /* This peer was alive during a 'reconnect' period.
2692 * Flag it as not alive again for the next period.
2693 */
2694 ps->flags &= ~PEER_F_ALIVE;
Frédéric Lécaille54bff832019-03-26 10:25:20 +01002695 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(PEER_RECONNECT_TIMEOUT));
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002696 }
2697 else {
2698 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + random() % 2000));
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002699 peer_session_forceshutdown(ps);
Frédéric Lécaille045e0d42019-03-21 11:12:32 +01002700 }
2701 }
2702 else if (tick_is_expired(ps->heartbeat, now_ms)) {
2703 ps->heartbeat = tick_add(now_ms, MS_TO_TICKS(PEER_HEARTBEAT_TIMEOUT));
2704 ps->flags |= PEER_F_HEARTBEAT;
2705 appctx_wakeup(ps->appctx);
2706 }
Frédéric Lécailleb7405c12019-03-27 14:32:39 +01002707 task->expire = tick_first(ps->reconnect, ps->heartbeat);
Frédéric Lécaille645635d2019-02-11 17:49:39 +01002708 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002709 }
2710 /* else do nothing */
2711 } /* SUCCESSCODE */
2712 } /* !ps->peer->local */
2713 } /* for */
2714
2715 /* Resync from remotes expired: consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002716 if (((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE) &&
2717 !(peers->flags & PEERS_F_RESYNC_ASSIGN) &&
2718 tick_is_expired(peers->resync_timeout, now_ms)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002719 /* Resync from remote peer needed
2720 * no peer was assigned for the lesson
2721 * and resync timeout expire */
2722
2723 /* flag no more resync from remote, consider resync is finished */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002724 peers->flags |= PEERS_F_RESYNC_REMOTE;
Emeric Brun2b920a12010-09-23 18:30:22 +02002725 }
2726
Emeric Brunb3971ab2015-05-12 18:49:09 +02002727 if ((peers->flags & PEERS_RESYNC_STATEMASK) != PEERS_RESYNC_FINISHED) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002728 /* Resync not finished*/
Frédéric Lécaille5d6e5f82017-05-29 13:47:16 +02002729 /* reschedule task to resync timeout if not expired, to ended resync if needed */
2730 if (!tick_is_expired(peers->resync_timeout, now_ms))
2731 task->expire = tick_first(task->expire, peers->resync_timeout);
Emeric Brun2b920a12010-09-23 18:30:22 +02002732 }
2733 } /* !stopping */
2734 else {
2735 /* soft stop case */
Willy Tarreau086735a2018-11-05 15:09:47 +01002736 if (state & TASK_WOKEN_SIGNAL) {
Joseph Herlant82b2f542018-11-15 12:19:14 -08002737 /* We've just received the signal */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002738 if (!(peers->flags & PEERS_F_DONOTSTOP)) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002739 /* add DO NOT STOP flag if not present */
Olivier Houcharded879892019-03-08 18:53:43 +01002740 _HA_ATOMIC_ADD(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002741 peers->flags |= PEERS_F_DONOTSTOP;
2742 ps = peers->local;
2743 for (st = ps->tables; st ; st = st->next)
2744 st->table->syncing++;
Emeric Brun2b920a12010-09-23 18:30:22 +02002745 }
2746
2747 /* disconnect all connected peers */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002748 for (ps = peers->remote; ps; ps = ps->next) {
Emeric Brun80527f52017-06-19 17:46:37 +02002749 /* we're killing a connection, we must apply a random delay before
2750 * retrying otherwise the other end will do the same and we can loop
2751 * for a while.
2752 */
2753 ps->reconnect = tick_add(now_ms, MS_TO_TICKS(50 + random() % 2000));
Willy Tarreau9df94c22016-10-31 18:42:52 +01002754 if (ps->appctx) {
Emeric Brun9ef2ad72019-04-02 17:22:01 +02002755 peer_session_forceshutdown(ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002756 }
2757 }
2758 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002759
Emeric Brunb3971ab2015-05-12 18:49:09 +02002760 ps = peers->local;
Emeric Brun2b920a12010-09-23 18:30:22 +02002761 if (ps->flags & PEER_F_TEACH_COMPLETE) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002762 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002763 /* resync of new process was complete, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002764 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002765 peers->flags &= ~PEERS_F_DONOTSTOP;
2766 for (st = ps->tables; st ; st = st->next)
2767 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002768 }
2769 }
Willy Tarreau9df94c22016-10-31 18:42:52 +01002770 else if (!ps->appctx) {
2771 /* If there's no active peer connection */
Emeric Brun2b920a12010-09-23 18:30:22 +02002772 if (ps->statuscode == 0 ||
Willy Tarreaue4d927a2013-12-01 12:47:35 +01002773 ps->statuscode == PEER_SESS_SC_SUCCESSCODE ||
2774 ps->statuscode == PEER_SESS_SC_CONNECTEDCODE ||
2775 ps->statuscode == PEER_SESS_SC_TRYAGAIN) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002776 /* connection never tried
Willy Tarreau9df94c22016-10-31 18:42:52 +01002777 * or previous peer connection was successfully established
2778 * or previous tcp connect succeeded but init state incomplete
Emeric Brun2b920a12010-09-23 18:30:22 +02002779 * or during previous connect, peer replies a try again statuscode */
2780
2781 /* connect to the peer */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002782 peer_session_create(peers, ps);
Emeric Brun2b920a12010-09-23 18:30:22 +02002783 }
2784 else {
2785 /* Other error cases */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002786 if (peers->flags & PEERS_F_DONOTSTOP) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002787 /* unable to resync new process, current process can die now */
Olivier Houcharded879892019-03-08 18:53:43 +01002788 _HA_ATOMIC_SUB(&jobs, 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002789 peers->flags &= ~PEERS_F_DONOTSTOP;
2790 for (st = ps->tables; st ; st = st->next)
2791 st->table->syncing--;
Emeric Brun2b920a12010-09-23 18:30:22 +02002792 }
2793 }
2794 }
Emeric Brunb3971ab2015-05-12 18:49:09 +02002795 else if (ps->statuscode == PEER_SESS_SC_SUCCESSCODE ) {
Willy Tarreau9df94c22016-10-31 18:42:52 +01002796 /* current peer connection is active and established
2797 * wake up all peer handlers to push remaining local updates */
Emeric Brunb3971ab2015-05-12 18:49:09 +02002798 for (st = ps->tables; st ; st = st->next) {
2799 if ((int)(st->last_pushed - st->table->localupdate) < 0) {
Emeric Brunb3971ab2015-05-12 18:49:09 +02002800 appctx_wakeup(ps->appctx);
2801 break;
2802 }
2803 }
Emeric Brun2b920a12010-09-23 18:30:22 +02002804 }
2805 } /* stopping */
Emeric Brun80527f52017-06-19 17:46:37 +02002806
2807 /* Release lock for all peers of the section */
2808 for (ps = peers->remote; ps; ps = ps->next)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002809 HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
Emeric Brun80527f52017-06-19 17:46:37 +02002810
Emeric Brun2b920a12010-09-23 18:30:22 +02002811 /* Wakeup for re-connect */
2812 return task;
2813}
2814
Emeric Brunb3971ab2015-05-12 18:49:09 +02002815
Emeric Brun2b920a12010-09-23 18:30:22 +02002816/*
Willy Tarreaud9443442018-10-15 11:18:03 +02002817 * returns 0 in case of error.
Emeric Brun2b920a12010-09-23 18:30:22 +02002818 */
Willy Tarreaud9443442018-10-15 11:18:03 +02002819int peers_init_sync(struct peers *peers)
Emeric Brun2b920a12010-09-23 18:30:22 +02002820{
Emeric Brun2b920a12010-09-23 18:30:22 +02002821 struct peer * curpeer;
Emeric Brun2b920a12010-09-23 18:30:22 +02002822
Emeric Brun2b920a12010-09-23 18:30:22 +02002823 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Emeric Brun2b920a12010-09-23 18:30:22 +02002824 peers->peers_fe->maxconn += 3;
2825 }
2826
Emeric Brunc60def82017-09-27 14:59:38 +02002827 peers->sync_task = task_new(MAX_THREADS_MASK);
Willy Tarreaud9443442018-10-15 11:18:03 +02002828 if (!peers->sync_task)
2829 return 0;
2830
Emeric Brunb3971ab2015-05-12 18:49:09 +02002831 peers->sync_task->process = process_peer_sync;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002832 peers->sync_task->context = (void *)peers;
2833 peers->sighandler = signal_register_task(0, peers->sync_task, 0);
2834 task_wakeup(peers->sync_task, TASK_WOKEN_INIT);
Willy Tarreaud9443442018-10-15 11:18:03 +02002835 return 1;
Emeric Brunb3971ab2015-05-12 18:49:09 +02002836}
2837
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002838/*
2839 * Allocate a cache a dictionary entries used upon transmission.
2840 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002841static struct dcache_tx *new_dcache_tx(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002842{
2843 struct dcache_tx *d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002844 struct ebpt_node *entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002845
2846 d = malloc(sizeof *d);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002847 entries = calloc(max_entries, sizeof *entries);
2848 if (!d || !entries)
2849 goto err;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002850
2851 d->lru_key = 0;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002852 d->prev_lookup = NULL;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002853 d->cached_entries = EB_ROOT_UNIQUE;
2854 d->entries = entries;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002855
2856 return d;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002857
2858 err:
2859 free(d);
2860 free(entries);
2861 return NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002862}
2863
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002864static void free_dcache_tx(struct dcache_tx *dc)
2865{
2866 free(dc->entries);
2867 dc->entries = NULL;
2868 free(dc);
2869}
2870
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002871/*
2872 * Allocate a cache of dictionary entries with <name> as name and <max_entries>
2873 * as maximum of entries.
2874 * Return the dictionay cache if succeeded, NULL if not.
2875 * Must be deallocated calling free_dcache().
2876 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002877static struct dcache *new_dcache(size_t max_entries)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002878{
2879 struct dcache_tx *dc_tx;
2880 struct dcache *dc;
2881 struct dcache_rx *dc_rx;
2882
2883 dc = calloc(1, sizeof *dc);
2884 dc_tx = new_dcache_tx(max_entries);
2885 dc_rx = calloc(max_entries, sizeof *dc_rx);
2886 if (!dc || !dc_tx || !dc_rx)
2887 goto err;
2888
2889 dc->tx = dc_tx;
2890 dc->rx = dc_rx;
2891 dc->max_entries = max_entries;
2892
2893 return dc;
2894
2895 err:
2896 free(dc);
2897 free(dc_tx);
2898 free(dc_rx);
2899 return NULL;
2900}
2901
2902/*
2903 * Deallocate a cache of dictionary entries.
2904 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002905static inline void free_dcache(struct dcache *dc)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002906{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002907 free_dcache_tx(dc->tx);
2908 dc->tx = NULL;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002909 free(dc->rx); dc->rx = NULL;
2910 free(dc);
2911}
2912
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002913
2914/*
2915 * Look for the dictionary entry with the value of <i> in <d> cache of dictionary
2916 * entries used upon transmission.
2917 * Return the entry if found, NULL if not.
2918 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002919static struct ebpt_node *dcache_tx_lookup_value(struct dcache_tx *d,
2920 struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002921{
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002922 return ebpt_lookup(&d->cached_entries, i->entry.key);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002923}
2924
2925/*
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002926 * Flush <dc> cache.
2927 * Always succeeds.
2928 */
2929static inline void flush_dcache(struct peer *peer)
2930{
2931 int i;
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002932 struct dcache *dc = peer->dcache;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002933
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002934 for (i = 0; i < dc->max_entries; i++)
2935 ebpt_delete(&dc->tx->entries[i]);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002936
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002937 memset(dc->rx, 0, dc->max_entries * sizeof *dc->rx);
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002938}
2939
2940/*
2941 * Insert a dictionary entry in <dc> cache part used upon transmission (->tx)
2942 * with information provided by <i> dictionary cache entry (especially the value
2943 * to be inserted if not already). Return <i> if already present in the cache
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002944 * or something different of <i> if not.
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002945 */
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002946static struct ebpt_node *dcache_tx_insert(struct dcache *dc, struct dcache_tx_entry *i)
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002947{
2948 struct dcache_tx *dc_tx;
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002949 struct ebpt_node *o;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002950
2951 dc_tx = dc->tx;
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002952
2953 if (dc_tx->prev_lookup && dc_tx->prev_lookup->key == i->entry.key) {
2954 o = dc_tx->prev_lookup;
2955 } else {
2956 o = dcache_tx_lookup_value(dc_tx, i);
2957 if (o) {
2958 /* Save it */
2959 dc_tx->prev_lookup = o;
2960 }
2961 }
2962
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002963 if (o) {
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002964 /* Copy the ID. */
2965 i->id = o - dc->tx->entries;
2966 return &i->entry;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002967 }
2968
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002969 /* The new entry to put in cache */
Frédéric Lécailleb65717f2019-06-07 14:25:25 +02002970 dc_tx->prev_lookup = o = &dc_tx->entries[dc_tx->lru_key];
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002971
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002972 ebpt_delete(o);
2973 o->key = i->entry.key;
2974 ebpt_insert(&dc_tx->cached_entries, o);
2975 i->id = dc_tx->lru_key;
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002976
Frédéric Lécaille6c391982019-06-06 11:34:03 +02002977 /* Update the index for the next entry to put in cache */
2978 dc_tx->lru_key = (dc_tx->lru_key + 1) & (dc->max_entries - 1);
Emeric Brunb3971ab2015-05-12 18:49:09 +02002979
Frédéric Lécaille74167b22019-05-28 19:02:42 +02002980 return o;
2981}
Emeric Brunb3971ab2015-05-12 18:49:09 +02002982
2983/*
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02002984 * Allocate a dictionary cache for each peer of <peers> section.
2985 * Return 1 if succeeded, 0 if not.
2986 */
2987int peers_alloc_dcache(struct peers *peers)
2988{
2989 struct peer *p;
2990
2991 for (p = peers->remote; p; p = p->next) {
2992 p->dcache = new_dcache(PEER_STKT_CACHE_MAX_ENTRIES);
2993 if (!p->dcache)
2994 return 0;
2995 }
2996
2997 return 1;
2998}
2999
3000/*
Emeric Brunb3971ab2015-05-12 18:49:09 +02003001 * Function used to register a table for sync on a group of peers
3002 *
3003 */
3004void peers_register_table(struct peers *peers, struct stktable *table)
3005{
3006 struct shared_table *st;
3007 struct peer * curpeer;
3008 int id = 0;
3009
3010 for (curpeer = peers->remote; curpeer; curpeer = curpeer->next) {
Vincent Bernat02779b62016-04-03 13:48:43 +02003011 st = calloc(1,sizeof(*st));
Emeric Brunb3971ab2015-05-12 18:49:09 +02003012 st->table = table;
3013 st->next = curpeer->tables;
3014 if (curpeer->tables)
3015 id = curpeer->tables->local_id;
3016 st->local_id = id + 1;
3017
3018 curpeer->tables = st;
3019 }
3020
3021 table->sync_task = peers->sync_task;
Emeric Brun2b920a12010-09-23 18:30:22 +02003022}
3023
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003024/*
3025 * Parse the "show peers" command arguments.
3026 * Returns 0 if succeeded, 1 if not with the ->msg of the appctx set as
3027 * error message.
3028 */
3029static int cli_parse_show_peers(char **args, char *payload, struct appctx *appctx, void *private)
3030{
3031 appctx->ctx.cfgpeers.target = NULL;
3032
3033 if (*args[2]) {
3034 struct peers *p;
3035
3036 for (p = cfg_peers; p; p = p->next) {
3037 if (!strcmp(p->id, args[2])) {
3038 appctx->ctx.cfgpeers.target = p;
3039 break;
3040 }
3041 }
3042
3043 if (!p) {
3044 appctx->ctx.cli.severity = LOG_ERR;
3045 appctx->ctx.cli.msg = "No such peers\n";
3046 appctx->st0 = CLI_ST_PRINT;
3047 return 1;
3048 }
3049 }
3050
3051 return 0;
3052}
3053
3054/*
3055 * This function dumps the peer state information of <peers> "peers" section.
3056 * Returns 0 if the output buffer is full and needs to be called again, non-zero if not.
3057 * Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3058 */
3059static int peers_dump_head(struct buffer *msg, struct stream_interface *si, struct peers *peers)
3060{
3061 struct tm tm;
3062
3063 get_localtime(peers->last_change, &tm);
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003064 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 +02003065 peers,
3066 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3067 tm.tm_hour, tm.tm_min, tm.tm_sec,
3068 peers->id, peers->state, peers->flags,
3069 peers->resync_timeout ?
3070 tick_is_expired(peers->resync_timeout, now_ms) ? "<PAST>" :
3071 human_time(TICKS_TO_MS(peers->resync_timeout - now_ms),
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003072 TICKS_TO_MS(1000)) : "<NEVER>",
3073 peers->sync_task ? peers->sync_task->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003074
3075 if (ci_putchk(si_ic(si), msg) == -1) {
3076 si_rx_room_blk(si);
3077 return 0;
3078 }
3079
3080 return 1;
3081}
3082
3083/*
3084 * This function dumps <peer> state information.
3085 * Returns 0 if the output buffer is full and needs to be called again, non-zero
3086 * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
3087 */
3088static int peers_dump_peer(struct buffer *msg, struct stream_interface *si, struct peer *peer)
3089{
3090 struct connection *conn;
3091 char pn[INET6_ADDRSTRLEN];
3092 struct stream_interface *peer_si;
3093 struct stream *peer_s;
3094 struct appctx *appctx;
3095 struct shared_table *st;
3096
3097 addr_to_str(&peer->addr, pn, sizeof pn);
3098 chunk_appendf(msg, " %p: id=%s(%s) addr=%s:%d status=%s reconnect=%s confirm=%u\n",
3099 peer, peer->id,
3100 peer->local ? "local" : "remote",
3101 pn, get_host_port(&peer->addr),
3102 statuscode_str(peer->statuscode),
3103 peer->reconnect ?
3104 tick_is_expired(peer->reconnect, now_ms) ? "<PAST>" :
3105 human_time(TICKS_TO_MS(peer->reconnect - now_ms),
3106 TICKS_TO_MS(1000)) : "<NEVER>",
3107 peer->confirm);
3108
3109 chunk_appendf(&trash, " flags=0x%x", peer->flags);
3110
3111 appctx = peer->appctx;
3112 if (!appctx)
3113 goto end;
3114
Emeric Brun0bbec0f2019-04-18 11:39:43 +02003115 chunk_appendf(&trash, " appctx:%p st0=%d st1=%d task_calls=%u", appctx, appctx->st0, appctx->st1,
3116 appctx->t ? appctx->t->calls : 0);
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003117
3118 peer_si = peer->appctx->owner;
3119 if (!peer_si)
3120 goto end;
3121
3122 peer_s = si_strm(peer_si);
3123 if (!peer_s)
3124 goto end;
3125
3126 chunk_appendf(&trash, " state=%s", si_state_str(si_opposite(peer_si)->state));
3127
3128 conn = objt_conn(strm_orig(peer_s));
3129 if (conn)
3130 chunk_appendf(&trash, "\n xprt=%s", conn_get_xprt_name(conn));
3131
3132 switch (conn ? addr_to_str(&conn->addr.from, pn, sizeof(pn)) : AF_UNSPEC) {
3133 case AF_INET:
3134 case AF_INET6:
3135 chunk_appendf(&trash, " src=%s:%d", pn, get_host_port(&conn->addr.from));
3136 break;
3137 case AF_UNIX:
3138 chunk_appendf(&trash, " src=unix:%d", strm_li(peer_s)->luid);
3139 break;
3140 }
3141
3142 if (conn)
3143 conn_get_to_addr(conn);
3144
3145 switch (conn ? addr_to_str(&conn->addr.to, pn, sizeof(pn)) : AF_UNSPEC) {
3146 case AF_INET:
3147 case AF_INET6:
3148 chunk_appendf(&trash, " addr=%s:%d", pn, get_host_port(&conn->addr.to));
3149 break;
3150 case AF_UNIX:
3151 chunk_appendf(&trash, " addr=unix:%d", strm_li(peer_s)->luid);
3152 break;
3153 }
3154
3155 if (peer->remote_table)
3156 chunk_appendf(&trash, "\n remote_table:%p id=%s local_id=%d remote_id=%d",
3157 peer->remote_table,
3158 peer->remote_table->table->id,
3159 peer->remote_table->local_id,
3160 peer->remote_table->remote_id);
3161
3162 if (peer->last_local_table)
3163 chunk_appendf(&trash, "\n last_local_table:%p id=%s local_id=%d remote_id=%d",
3164 peer->last_local_table,
3165 peer->last_local_table->table->id,
3166 peer->last_local_table->local_id,
3167 peer->last_local_table->remote_id);
3168
3169 if (peer->tables) {
3170 chunk_appendf(&trash, "\n shared tables:");
3171 for (st = peer->tables; st; st = st->next) {
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003172 int i, count;
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003173 struct stktable *t;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003174 struct dcache *dcache;
3175
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003176 t = st->table;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003177 dcache = peer->dcache;
3178
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003179 chunk_appendf(&trash, "\n %p local_id=%d remote_id=%d "
3180 "flags=0x%x remote_data=0x%llx",
3181 st, st->local_id, st->remote_id,
3182 st->flags, (unsigned long long)st->remote_data);
3183 chunk_appendf(&trash, "\n last_acked=%u last_pushed=%u last_get=%u"
3184 " teaching_origin=%u update=%u",
3185 st->last_acked, st->last_pushed, st->last_get,
3186 st->teaching_origin, st->update);
3187 chunk_appendf(&trash, "\n table:%p id=%s update=%u localupdate=%u"
3188 " commitupdate=%u syncing=%u",
3189 t, t->id, t->update, t->localupdate, t->commitupdate, t->syncing);
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003190 chunk_appendf(&trash, "\n TX dictionary cache:");
3191 count = 0;
3192 for (i = 0; i < dcache->max_entries; i++) {
3193 struct ebpt_node *node;
3194 struct dict_entry *de;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003195
Frédéric Lécaille6c391982019-06-06 11:34:03 +02003196 node = &dcache->tx->entries[i];
3197 if (!node->key)
3198 break;
3199
3200 if (!count++)
3201 chunk_appendf(&trash, "\n ");
3202 de = node->key;
3203 chunk_appendf(&trash, " %3u -> %s", i, (char *)de->value.key);
3204 count &= 0x3;
Frédéric Lécaille62b0b0b2019-05-29 16:20:41 +02003205 }
3206 chunk_appendf(&trash, "\n RX dictionary cache:");
3207 count = 0;
3208 for (i = 0; i < dcache->max_entries; i++) {
3209 if (!count++)
3210 chunk_appendf(&trash, "\n ");
3211 chunk_appendf(&trash, " %3u -> %s", i,
3212 dcache->rx[i].de ?
3213 (char *)dcache->rx[i].de->value.key : "-");
3214 count &= 0x3;
3215 }
Frédéric Lécaille95679dc2019-04-15 10:25:27 +02003216 }
3217 }
3218
3219 end:
3220 chunk_appendf(&trash, "\n");
3221 if (ci_putchk(si_ic(si), msg) == -1) {
3222 si_rx_room_blk(si);
3223 return 0;
3224 }
3225
3226 return 1;
3227}
3228
3229/*
3230 * This function dumps all the peers of "peers" section.
3231 * Returns 0 if the output buffer is full and needs to be called
3232 * again, non-zero if not. It proceeds in an isolated thread, so
3233 * there is no thread safety issue here.
3234 */
3235static int cli_io_handler_show_peers(struct appctx *appctx)
3236{
3237 int show_all;
3238 int ret = 0, first_peers = 1;
3239 struct stream_interface *si = appctx->owner;
3240
3241 thread_isolate();
3242
3243 show_all = !appctx->ctx.cfgpeers.target;
3244
3245 chunk_reset(&trash);
3246
3247 while (appctx->st2 != STAT_ST_FIN) {
3248 switch (appctx->st2) {
3249 case STAT_ST_INIT:
3250 if (show_all)
3251 appctx->ctx.cfgpeers.peers = cfg_peers;
3252 else
3253 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.target;
3254
3255 appctx->st2 = STAT_ST_LIST;
3256 /* fall through */
3257
3258 case STAT_ST_LIST:
3259 if (!appctx->ctx.cfgpeers.peers) {
3260 /* No more peers list. */
3261 appctx->st2 = STAT_ST_END;
3262 }
3263 else {
3264 if (!first_peers)
3265 chunk_appendf(&trash, "\n");
3266 else
3267 first_peers = 0;
3268 if (!peers_dump_head(&trash, si, appctx->ctx.cfgpeers.peers))
3269 goto out;
3270
3271 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peers->remote;
3272 appctx->ctx.cfgpeers.peers = appctx->ctx.cfgpeers.peers->next;
3273 appctx->st2 = STAT_ST_INFO;
3274 }
3275 break;
3276
3277 case STAT_ST_INFO:
3278 if (!appctx->ctx.cfgpeers.peer) {
3279 /* End of peer list */
3280 if (show_all)
3281 appctx->st2 = STAT_ST_LIST;
3282 else
3283 appctx->st2 = STAT_ST_END;
3284 }
3285 else {
3286 if (!peers_dump_peer(&trash, si, appctx->ctx.cfgpeers.peer))
3287 goto out;
3288
3289 appctx->ctx.cfgpeers.peer = appctx->ctx.cfgpeers.peer->next;
3290 }
3291 break;
3292
3293 case STAT_ST_END:
3294 appctx->st2 = STAT_ST_FIN;
3295 break;
3296 }
3297 }
3298 ret = 1;
3299 out:
3300 thread_release();
3301 return ret;
3302}
3303
3304/*
3305 * CLI keywords.
3306 */
3307static struct cli_kw_list cli_kws = {{ }, {
3308 { { "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, },
3309 {},
3310}};
3311
3312/* Register cli keywords */
3313INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3314