blob: 2cac07486e37c181fbe731c4102d67700b96d45e [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * General logging functions.
3 *
Willy Tarreaub7f694f2008-06-22 17:18:02 +02004 * Copyright 2000-2008 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
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
Willy Tarreau8a3f52f2012-12-20 21:23:42 +010013#include <ctype.h>
Willy Tarreauc8f24f82007-11-30 18:38:35 +010014#include <fcntl.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020015#include <stdarg.h>
16#include <stdio.h>
17#include <stdlib.h>
18#include <string.h>
19#include <syslog.h>
20#include <time.h>
21#include <unistd.h>
Robert Tsai81ae1952007-12-05 10:47:29 +010022#include <errno.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020023
24#include <sys/time.h>
Willy Tarreau077edcb2016-08-10 18:30:56 +020025#include <sys/uio.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020026
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020027#include <common/config.h>
Willy Tarreaud6d06902009-08-19 11:22:33 +020028#include <common/compat.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010029#include <common/initcall.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020030#include <common/standard.h>
Willy Tarreaufb278672006-10-15 15:38:50 +020031#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020032
Christopher Fauletc1b730a2017-10-24 12:00:51 +020033#include <types/cli.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034#include <types/global.h>
William Lallemand723b73a2012-02-08 16:37:49 +010035#include <types/log.h>
Willy Tarreauec6c5df2008-07-15 00:22:45 +020036
Christopher Fauletc1b730a2017-10-24 12:00:51 +020037#include <proto/applet.h>
38#include <proto/cli.h>
Willy Tarreaud52a7f82019-08-30 14:05:35 +020039#include <proto/fd.h>
William Lallemand5f232402012-04-05 18:02:55 +020040#include <proto/frontend.h>
Willy Tarreauec6c5df2008-07-15 00:22:45 +020041#include <proto/log.h>
Willy Tarreauc046d162019-08-30 15:24:59 +020042#include <proto/ring.h>
Willy Tarreauc8368452012-12-21 00:09:23 +010043#include <proto/sample.h>
Willy Tarreauc046d162019-08-30 15:24:59 +020044#include <proto/sink.h>
Willy Tarreauc125cef2019-05-10 09:58:43 +020045#include <proto/ssl_sock.h>
Willy Tarreaufb0afa72015-04-03 14:46:27 +020046#include <proto/stream.h>
Willy Tarreau827aee92011-03-10 16:55:02 +010047#include <proto/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020048
Dragan Dosen43885c72015-10-01 13:18:13 +020049struct log_fmt {
50 char *name;
51 struct {
Willy Tarreau83061a82018-07-13 11:56:34 +020052 struct buffer sep1; /* first pid separator */
53 struct buffer sep2; /* second pid separator */
Dragan Dosen43885c72015-10-01 13:18:13 +020054 } pid;
55};
56
57static const struct log_fmt log_formats[LOG_FORMATS] = {
58 [LOG_FORMAT_RFC3164] = {
59 .name = "rfc3164",
60 .pid = {
Willy Tarreau843b7cb2018-07-13 10:54:26 +020061 .sep1 = { .area = "[", .data = 1 },
62 .sep2 = { .area = "]: ", .data = 3 }
Dragan Dosen43885c72015-10-01 13:18:13 +020063 }
64 },
65 [LOG_FORMAT_RFC5424] = {
66 .name = "rfc5424",
67 .pid = {
Willy Tarreau843b7cb2018-07-13 10:54:26 +020068 .sep1 = { .area = " ", .data = 1 },
69 .sep2 = { .area = " - ", .data = 3 }
Dragan Dosen43885c72015-10-01 13:18:13 +020070 }
Willy Tarreaue8746a02018-11-12 08:45:00 +010071 },
72 [LOG_FORMAT_SHORT] = {
73 .name = "short",
74 .pid = {
75 .sep1 = { .area = "", .data = 0 },
76 .sep2 = { .area = " ", .data = 1 },
77 }
78 },
Willy Tarreauc1b06452018-11-12 11:57:56 +010079 [LOG_FORMAT_RAW] = {
80 .name = "raw",
81 .pid = {
82 .sep1 = { .area = "", .data = 0 },
83 .sep2 = { .area = "", .data = 0 },
84 }
85 },
Dragan Dosen1322d092015-09-22 16:05:32 +020086};
87
Dragan Dosen835b9212016-02-12 13:23:03 +010088/*
89 * This map is used with all the FD_* macros to check whether a particular bit
Willy Tarreau1bfd6022019-06-07 11:10:07 +020090 * is set or not. Each bit represents an ACSII code. ha_bit_set() sets those
91 * bytes which should be escaped. When ha_bit_test() returns non-zero, it means
92 * that the byte should be escaped. Be careful to always pass bytes from 0 to
93 * 255 exclusively to the macros.
Dragan Dosen835b9212016-02-12 13:23:03 +010094 */
Willy Tarreau1bfd6022019-06-07 11:10:07 +020095long rfc5424_escape_map[(256/8) / sizeof(long)];
96long hdr_encode_map[(256/8) / sizeof(long)];
97long url_encode_map[(256/8) / sizeof(long)];
98long http_encode_map[(256/8) / sizeof(long)];
Dragan Dosen835b9212016-02-12 13:23:03 +010099
Dragan Dosen835b9212016-02-12 13:23:03 +0100100
Willy Tarreaubaaee002006-06-26 02:48:02 +0200101const char *log_facilities[NB_LOG_FACILITIES] = {
102 "kern", "user", "mail", "daemon",
103 "auth", "syslog", "lpr", "news",
104 "uucp", "cron", "auth2", "ftp",
105 "ntp", "audit", "alert", "cron2",
106 "local0", "local1", "local2", "local3",
107 "local4", "local5", "local6", "local7"
108};
109
Willy Tarreaubaaee002006-06-26 02:48:02 +0200110const char *log_levels[NB_LOG_LEVELS] = {
111 "emerg", "alert", "crit", "err",
112 "warning", "notice", "info", "debug"
113};
114
Willy Tarreau570f2212013-06-10 16:42:09 +0200115const char sess_term_cond[16] = "-LcCsSPRIDKUIIII"; /* normal, Local, CliTo, CliErr, SrvTo, SrvErr, PxErr, Resource, Internal, Down, Killed, Up, -- */
Willy Tarreaub8750a82006-09-03 09:56:00 +0200116const char sess_fin_state[8] = "-RCHDLQT"; /* cliRequest, srvConnect, srvHeader, Data, Last, Queue, Tarpit */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200117
William Lallemand723b73a2012-02-08 16:37:49 +0100118
119/* log_format */
120struct logformat_type {
121 char *name;
122 int type;
William Lallemandbddd4fd2012-02-27 11:23:10 +0100123 int mode;
William Lallemand5e19a282012-04-02 16:22:10 +0200124 int lw; /* logwait bitsfield */
William Lallemandb7ff6a32012-03-02 14:35:21 +0100125 int (*config_callback)(struct logformat_node *node, struct proxy *curproxy);
Willy Tarreau2beef582012-12-20 17:22:52 +0100126 const char *replace_by; /* new option to use instead of old one */
William Lallemand723b73a2012-02-08 16:37:49 +0100127};
128
William Lallemandb7ff6a32012-03-02 14:35:21 +0100129int prepare_addrsource(struct logformat_node *node, struct proxy *curproxy);
130
William Lallemand723b73a2012-02-08 16:37:49 +0100131/* log_format variable names */
132static const struct logformat_type logformat_keywords[] = {
William Lallemand5e19a282012-04-02 16:22:10 +0200133 { "o", LOG_FMT_GLOBAL, PR_MODE_TCP, 0, NULL }, /* global option */
Willy Tarreau2beef582012-12-20 17:22:52 +0100134
135 /* please keep these lines sorted ! */
136 { "B", LOG_FMT_BYTES, PR_MODE_TCP, LW_BYTES, NULL }, /* bytes from server to client */
137 { "CC", LOG_FMT_CCLIENT, PR_MODE_HTTP, LW_REQHDR, NULL }, /* client cookie */
138 { "CS", LOG_FMT_CSERVER, PR_MODE_HTTP, LW_RSPHDR, NULL }, /* server cookie */
139 { "H", LOG_FMT_HOSTNAME, PR_MODE_TCP, LW_INIT, NULL }, /* Hostname */
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100140 { "ID", LOG_FMT_UNIQUEID, PR_MODE_TCP, LW_BYTES, NULL }, /* Unique ID */
Willy Tarreau4bf99632014-06-13 12:21:40 +0200141 { "ST", LOG_FMT_STATUS, PR_MODE_TCP, LW_RESP, NULL }, /* status code */
William Lallemand5e19a282012-04-02 16:22:10 +0200142 { "T", LOG_FMT_DATEGMT, PR_MODE_TCP, LW_INIT, NULL }, /* date GMT */
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +0200143 { "Ta", LOG_FMT_Ta, PR_MODE_HTTP, LW_BYTES, NULL }, /* Time active (tr to end) */
Willy Tarreau2beef582012-12-20 17:22:52 +0100144 { "Tc", LOG_FMT_TC, PR_MODE_TCP, LW_BYTES, NULL }, /* Tc */
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +0200145 { "Th", LOG_FMT_Th, PR_MODE_TCP, LW_BYTES, NULL }, /* Time handshake */
146 { "Ti", LOG_FMT_Ti, PR_MODE_HTTP, LW_BYTES, NULL }, /* Time idle */
147 { "Tl", LOG_FMT_DATELOCAL, PR_MODE_TCP, LW_INIT, NULL }, /* date local timezone */
148 { "Tq", LOG_FMT_TQ, PR_MODE_HTTP, LW_BYTES, NULL }, /* Tq=Th+Ti+TR */
149 { "Tr", LOG_FMT_Tr, PR_MODE_HTTP, LW_BYTES, NULL }, /* Tr */
150 { "TR", LOG_FMT_TR, PR_MODE_HTTP, LW_BYTES, NULL }, /* Time to receive a valid request */
Willy Tarreau27b639d2016-05-17 17:55:27 +0200151 { "Td", LOG_FMT_TD, PR_MODE_TCP, LW_BYTES, NULL }, /* Td = Tt - (Tq + Tw + Tc + Tr) */
Willy Tarreau2beef582012-12-20 17:22:52 +0100152 { "Ts", LOG_FMT_TS, PR_MODE_TCP, LW_INIT, NULL }, /* timestamp GMT */
William Lallemand5e19a282012-04-02 16:22:10 +0200153 { "Tt", LOG_FMT_TT, PR_MODE_TCP, LW_BYTES, NULL }, /* Tt */
Willy Tarreau2beef582012-12-20 17:22:52 +0100154 { "Tw", LOG_FMT_TW, PR_MODE_TCP, LW_BYTES, NULL }, /* Tw */
155 { "U", LOG_FMT_BYTES_UP, PR_MODE_TCP, LW_BYTES, NULL }, /* bytes from client to server */
William Lallemand5e19a282012-04-02 16:22:10 +0200156 { "ac", LOG_FMT_ACTCONN, PR_MODE_TCP, LW_BYTES, NULL }, /* actconn */
Willy Tarreau2beef582012-12-20 17:22:52 +0100157 { "b", LOG_FMT_BACKEND, PR_MODE_TCP, LW_INIT, NULL }, /* backend */
William Lallemand5e19a282012-04-02 16:22:10 +0200158 { "bc", LOG_FMT_BECONN, PR_MODE_TCP, LW_BYTES, NULL }, /* beconn */
Willy Tarreau2beef582012-12-20 17:22:52 +0100159 { "bi", LOG_FMT_BACKENDIP, PR_MODE_TCP, LW_BCKIP, prepare_addrsource }, /* backend source ip */
160 { "bp", LOG_FMT_BACKENDPORT, PR_MODE_TCP, LW_BCKIP, prepare_addrsource }, /* backend source port */
William Lallemand5e19a282012-04-02 16:22:10 +0200161 { "bq", LOG_FMT_BCKQUEUE, PR_MODE_TCP, LW_BYTES, NULL }, /* backend_queue */
Willy Tarreaud02286d2017-06-23 11:23:43 +0200162 { "ci", LOG_FMT_CLIENTIP, PR_MODE_TCP, LW_CLIP | LW_XPRT, NULL }, /* client ip */
163 { "cp", LOG_FMT_CLIENTPORT, PR_MODE_TCP, LW_CLIP | LW_XPRT, NULL }, /* client port */
Willy Tarreau2beef582012-12-20 17:22:52 +0100164 { "f", LOG_FMT_FRONTEND, PR_MODE_TCP, LW_INIT, NULL }, /* frontend */
165 { "fc", LOG_FMT_FECONN, PR_MODE_TCP, LW_BYTES, NULL }, /* feconn */
Willy Tarreaud02286d2017-06-23 11:23:43 +0200166 { "fi", LOG_FMT_FRONTENDIP, PR_MODE_TCP, LW_FRTIP | LW_XPRT, NULL }, /* frontend ip */
167 { "fp", LOG_FMT_FRONTENDPORT, PR_MODE_TCP, LW_FRTIP | LW_XPRT, NULL }, /* frontend port */
Willy Tarreau2beef582012-12-20 17:22:52 +0100168 { "ft", LOG_FMT_FRONTEND_XPRT, PR_MODE_TCP, LW_INIT, NULL }, /* frontend with transport mode */
Willy Tarreaud9ed3d22014-06-13 12:23:06 +0200169 { "hr", LOG_FMT_HDRREQUEST, PR_MODE_TCP, LW_REQHDR, NULL }, /* header request */
170 { "hrl", LOG_FMT_HDRREQUESTLIST, PR_MODE_TCP, LW_REQHDR, NULL }, /* header request list */
171 { "hs", LOG_FMT_HDRRESPONS, PR_MODE_TCP, LW_RSPHDR, NULL }, /* header response */
172 { "hsl", LOG_FMT_HDRRESPONSLIST, PR_MODE_TCP, LW_RSPHDR, NULL }, /* header response list */
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +0000173 { "HM", LOG_FMT_HTTP_METHOD, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP method */
174 { "HP", LOG_FMT_HTTP_PATH, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP path */
Andrew Hayworthe63ac872015-07-31 16:14:16 +0000175 { "HQ", LOG_FMT_HTTP_QUERY, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP query */
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +0000176 { "HU", LOG_FMT_HTTP_URI, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP full URI */
177 { "HV", LOG_FMT_HTTP_VERSION, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP version */
Willy Tarreau7346acb2014-08-28 15:03:15 +0200178 { "lc", LOG_FMT_LOGCNT, PR_MODE_TCP, LW_INIT, NULL }, /* log counter */
Willy Tarreau2beef582012-12-20 17:22:52 +0100179 { "ms", LOG_FMT_MS, PR_MODE_TCP, LW_INIT, NULL }, /* accept date millisecond */
William Lallemand5e19a282012-04-02 16:22:10 +0200180 { "pid", LOG_FMT_PID, PR_MODE_TCP, LW_INIT, NULL }, /* log pid */
Willy Tarreau2beef582012-12-20 17:22:52 +0100181 { "r", LOG_FMT_REQ, PR_MODE_HTTP, LW_REQ, NULL }, /* request */
182 { "rc", LOG_FMT_RETRIES, PR_MODE_TCP, LW_BYTES, NULL }, /* retries */
Willy Tarreau1f0da242014-01-25 11:01:50 +0100183 { "rt", LOG_FMT_COUNTER, PR_MODE_TCP, LW_REQ, NULL }, /* request counter (HTTP or TCP session) */
Willy Tarreau2beef582012-12-20 17:22:52 +0100184 { "s", LOG_FMT_SERVER, PR_MODE_TCP, LW_SVID, NULL }, /* server */
185 { "sc", LOG_FMT_SRVCONN, PR_MODE_TCP, LW_BYTES, NULL }, /* srv_conn */
186 { "si", LOG_FMT_SERVERIP, PR_MODE_TCP, LW_SVIP, NULL }, /* server destination ip */
187 { "sp", LOG_FMT_SERVERPORT, PR_MODE_TCP, LW_SVIP, NULL }, /* server destination port */
188 { "sq", LOG_FMT_SRVQUEUE, PR_MODE_TCP, LW_BYTES, NULL }, /* srv_queue */
Willy Tarreauffc3fcd2012-10-12 20:17:54 +0200189 { "sslc", LOG_FMT_SSL_CIPHER, PR_MODE_TCP, LW_XPRT, NULL }, /* client-side SSL ciphers */
190 { "sslv", LOG_FMT_SSL_VERSION, PR_MODE_TCP, LW_XPRT, NULL }, /* client-side SSL protocol version */
Willy Tarreau2beef582012-12-20 17:22:52 +0100191 { "t", LOG_FMT_DATE, PR_MODE_TCP, LW_INIT, NULL }, /* date */
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +0200192 { "tr", LOG_FMT_tr, PR_MODE_HTTP, LW_INIT, NULL }, /* date of start of request */
193 { "trg",LOG_FMT_trg, PR_MODE_HTTP, LW_INIT, NULL }, /* date of start of request, GMT */
194 { "trl",LOG_FMT_trl, PR_MODE_HTTP, LW_INIT, NULL }, /* date of start of request, local */
Willy Tarreau2beef582012-12-20 17:22:52 +0100195 { "ts", LOG_FMT_TERMSTATE, PR_MODE_TCP, LW_BYTES, NULL },/* termination state */
196 { "tsc", LOG_FMT_TERMSTATE_CK, PR_MODE_TCP, LW_INIT, NULL },/* termination state */
197
198 /* The following tags are deprecated and will be removed soon */
199 { "Bi", LOG_FMT_BACKENDIP, PR_MODE_TCP, LW_BCKIP, prepare_addrsource, "bi" }, /* backend source ip */
200 { "Bp", LOG_FMT_BACKENDPORT, PR_MODE_TCP, LW_BCKIP, prepare_addrsource, "bp" }, /* backend source port */
Willy Tarreaud02286d2017-06-23 11:23:43 +0200201 { "Ci", LOG_FMT_CLIENTIP, PR_MODE_TCP, LW_CLIP | LW_XPRT, NULL, "ci" }, /* client ip */
202 { "Cp", LOG_FMT_CLIENTPORT, PR_MODE_TCP, LW_CLIP | LW_XPRT, NULL, "cp" }, /* client port */
203 { "Fi", LOG_FMT_FRONTENDIP, PR_MODE_TCP, LW_FRTIP | LW_XPRT, NULL, "fi" }, /* frontend ip */
204 { "Fp", LOG_FMT_FRONTENDPORT, PR_MODE_TCP, LW_FRTIP | LW_XPRT, NULL, "fp" }, /* frontend port */
Willy Tarreau2beef582012-12-20 17:22:52 +0100205 { "Si", LOG_FMT_SERVERIP, PR_MODE_TCP, LW_SVIP, NULL, "si" }, /* server destination ip */
206 { "Sp", LOG_FMT_SERVERPORT, PR_MODE_TCP, LW_SVIP, NULL, "sp" }, /* server destination port */
207 { "cc", LOG_FMT_CCLIENT, PR_MODE_HTTP, LW_REQHDR, NULL, "CC" }, /* client cookie */
208 { "cs", LOG_FMT_CSERVER, PR_MODE_HTTP, LW_RSPHDR, NULL, "CS" }, /* server cookie */
209 { "st", LOG_FMT_STATUS, PR_MODE_HTTP, LW_RESP, NULL, "ST" }, /* status code */
William Lallemand5e19a282012-04-02 16:22:10 +0200210 { 0, 0, 0, 0, NULL }
William Lallemand723b73a2012-02-08 16:37:49 +0100211};
212
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +0200213char default_http_log_format[] = "%ci:%cp [%tr] %ft %b/%s %TR/%Tw/%Tc/%Tr/%Ta %ST %B %CC %CS %tsc %ac/%fc/%bc/%sc/%rc %sq/%bq %hr %hs %{+Q}r"; // default format
214char clf_http_log_format[] = "%{+Q}o %{-Q}ci - - [%trg] %r %ST %B \"\" \"\" %cp %ms %ft %b %s %TR %Tw %Tc %Tr %Ta %tsc %ac %fc %bc %sc %rc %sq %bq %CC %CS %hrl %hsl";
Willy Tarreau2beef582012-12-20 17:22:52 +0100215char default_tcp_log_format[] = "%ci:%cp [%t] %ft %b/%s %Tw/%Tc/%Tt %B %ts %ac/%fc/%bc/%sc/%rc %sq/%bq";
William Lallemand723b73a2012-02-08 16:37:49 +0100216char *log_format = NULL;
217
Dragan Dosen0b85ece2015-09-25 19:17:44 +0200218/* Default string used for structured-data part in RFC5424 formatted
219 * syslog messages.
220 */
221char default_rfc5424_sd_log_format[] = "- ";
Dragan Dosen1322d092015-09-22 16:05:32 +0200222
Willy Tarreau13ef7732018-11-12 07:25:28 +0100223/* total number of dropped logs */
224unsigned int dropped_logs = 0;
225
Dragan Dosen1322d092015-09-22 16:05:32 +0200226/* This is a global syslog header, common to all outgoing messages in
227 * RFC3164 format. It begins with time-based part and is updated by
228 * update_log_hdr().
Dragan Dosen59cee972015-09-19 22:09:02 +0200229 */
Christopher Fauletf8188c62017-06-02 16:20:16 +0200230THREAD_LOCAL char *logheader = NULL;
Willy Tarreau55e2f5a2019-05-05 10:11:39 +0200231THREAD_LOCAL char *logheader_end = NULL;
Dragan Dosen59cee972015-09-19 22:09:02 +0200232
Dragan Dosen1322d092015-09-22 16:05:32 +0200233/* This is a global syslog header for messages in RFC5424 format. It is
234 * updated by update_log_hdr_rfc5424().
235 */
Christopher Fauletf8188c62017-06-02 16:20:16 +0200236THREAD_LOCAL char *logheader_rfc5424 = NULL;
Willy Tarreau55e2f5a2019-05-05 10:11:39 +0200237THREAD_LOCAL char *logheader_rfc5424_end = NULL;
Dragan Dosen1322d092015-09-22 16:05:32 +0200238
Dragan Dosen59cee972015-09-19 22:09:02 +0200239/* This is a global syslog message buffer, common to all outgoing
240 * messages. It contains only the data part.
Willy Tarreaub1a2faf2012-03-19 16:51:53 +0100241 */
Christopher Fauletf8188c62017-06-02 16:20:16 +0200242THREAD_LOCAL char *logline = NULL;
Willy Tarreaub1a2faf2012-03-19 16:51:53 +0100243
Dragan Dosen0b85ece2015-09-25 19:17:44 +0200244/* A global syslog message buffer, common to all RFC5424 syslog messages.
245 * Currently, it is used for generating the structured-data part.
246 */
Christopher Fauletf8188c62017-06-02 16:20:16 +0200247THREAD_LOCAL char *logline_rfc5424 = NULL;
Dragan Dosen0b85ece2015-09-25 19:17:44 +0200248
Christopher Fauletd4696382017-10-24 11:44:05 +0200249/* A global buffer used to store all startup alerts/warnings. It will then be
250 * retrieve on the CLI. */
Willy Tarreau869efd52019-11-15 15:16:57 +0100251static struct ring *startup_logs = NULL;
Christopher Fauletd4696382017-10-24 11:44:05 +0200252
William Lallemand723b73a2012-02-08 16:37:49 +0100253struct logformat_var_args {
254 char *name;
255 int mask;
256};
257
258struct logformat_var_args var_args_list[] = {
259// global
260 { "M", LOG_OPT_MANDATORY },
261 { "Q", LOG_OPT_QUOTE },
William Lallemand5f232402012-04-05 18:02:55 +0200262 { "X", LOG_OPT_HEXA },
Dragan Dosen835b9212016-02-12 13:23:03 +0100263 { "E", LOG_OPT_ESC },
William Lallemand723b73a2012-02-08 16:37:49 +0100264 { 0, 0 }
265};
266
Willy Tarreaub1f3af22013-04-12 18:30:32 +0200267/* return the name of the directive used in the current proxy for which we're
268 * currently parsing a header, when it is known.
269 */
270static inline const char *fmt_directive(const struct proxy *curproxy)
271{
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100272 switch (curproxy->conf.args.ctx) {
Willy Tarreau53e1a6d2015-07-09 11:20:00 +0200273 case ARGC_ACL:
274 return "acl";
275 case ARGC_STK:
276 return "stick";
277 case ARGC_TRK:
278 return "track-sc";
279 case ARGC_LOG:
280 return "log-format";
Dragan Dosen0b85ece2015-09-25 19:17:44 +0200281 case ARGC_LOGSD:
282 return "log-format-sd";
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100283 case ARGC_HRQ:
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +0100284 return "http-request";
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100285 case ARGC_HRS:
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +0100286 return "http-response";
Willy Tarreau53e1a6d2015-07-09 11:20:00 +0200287 case ARGC_UIF:
288 return "unique-id-format";
Thierry FOURNIERd18cd0f2013-11-29 12:15:45 +0100289 case ARGC_RDR:
Willy Tarreau53e1a6d2015-07-09 11:20:00 +0200290 return "redirect";
291 case ARGC_CAP:
292 return "capture";
Willy Tarreau28d976d2015-07-09 11:39:33 +0200293 case ARGC_SRV:
294 return "server";
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200295 case ARGC_SPOE:
296 return "spoe-message";
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +0100297 case ARGC_UBK:
298 return "use_backend";
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100299 default:
Willy Tarreau53e1a6d2015-07-09 11:20:00 +0200300 return "undefined(please report this bug)"; /* must never happen */
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100301 }
Willy Tarreaub1f3af22013-04-12 18:30:32 +0200302}
303
William Lallemand723b73a2012-02-08 16:37:49 +0100304/*
William Lallemandb7ff6a32012-03-02 14:35:21 +0100305 * callback used to configure addr source retrieval
306 */
307int prepare_addrsource(struct logformat_node *node, struct proxy *curproxy)
308{
309 curproxy->options2 |= PR_O2_SRC_ADDR;
310
311 return 0;
312}
313
314
315/*
Thierry FOURNIER / OZON.IObca46f02016-11-22 23:13:04 +0100316 * Parse args in a logformat_var. Returns 0 in error
317 * case, otherwise, it returns 1.
William Lallemand723b73a2012-02-08 16:37:49 +0100318 */
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100319int parse_logformat_var_args(char *args, struct logformat_node *node, char **err)
William Lallemand723b73a2012-02-08 16:37:49 +0100320{
321 int i = 0;
322 int end = 0;
323 int flags = 0; // 1 = + 2 = -
324 char *sp = NULL; // start pointer
325
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100326 if (args == NULL) {
327 memprintf(err, "internal error: parse_logformat_var_args() expects non null 'args'");
Thierry FOURNIER / OZON.IObca46f02016-11-22 23:13:04 +0100328 return 0;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100329 }
William Lallemand723b73a2012-02-08 16:37:49 +0100330
331 while (1) {
332 if (*args == '\0')
333 end = 1;
334
335 if (*args == '+') {
336 // add flag
337 sp = args + 1;
338 flags = 1;
339 }
340 if (*args == '-') {
341 // delete flag
342 sp = args + 1;
343 flags = 2;
344 }
345
346 if (*args == '\0' || *args == ',') {
347 *args = '\0';
Willy Tarreau254d44c2012-12-20 18:19:26 +0100348 for (i = 0; sp && var_args_list[i].name; i++) {
William Lallemand723b73a2012-02-08 16:37:49 +0100349 if (strcmp(sp, var_args_list[i].name) == 0) {
350 if (flags == 1) {
351 node->options |= var_args_list[i].mask;
352 break;
353 } else if (flags == 2) {
354 node->options &= ~var_args_list[i].mask;
355 break;
356 }
357 }
358 }
359 sp = NULL;
360 if (end)
361 break;
362 }
Willy Tarreau254d44c2012-12-20 18:19:26 +0100363 args++;
William Lallemand723b73a2012-02-08 16:37:49 +0100364 }
Thierry FOURNIER / OZON.IObca46f02016-11-22 23:13:04 +0100365 return 1;
William Lallemand723b73a2012-02-08 16:37:49 +0100366}
367
368/*
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100369 * Parse a variable '%varname' or '%{args}varname' in log-format. The caller
370 * must pass the args part in the <arg> pointer with its length in <arg_len>,
371 * and varname with its length in <var> and <var_len> respectively. <arg> is
372 * ignored when arg_len is 0. Neither <var> nor <var_len> may be null.
Thierry FOURNIER / OZON.IOeca4d952016-11-22 22:06:04 +0100373 * Returns false in error case and err is filled, otherwise returns true.
William Lallemand723b73a2012-02-08 16:37:49 +0100374 */
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100375int parse_logformat_var(char *arg, int arg_len, char *var, int var_len, struct proxy *curproxy, struct list *list_format, int *defoptions, char **err)
William Lallemand723b73a2012-02-08 16:37:49 +0100376{
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100377 int j;
Dragan Dosen61302da2019-04-30 00:40:02 +0200378 struct logformat_node *node = NULL;
William Lallemand723b73a2012-02-08 16:37:49 +0100379
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100380 for (j = 0; logformat_keywords[j].name; j++) { // search a log type
381 if (strlen(logformat_keywords[j].name) == var_len &&
382 strncmp(var, logformat_keywords[j].name, var_len) == 0) {
383 if (logformat_keywords[j].mode != PR_MODE_HTTP || curproxy->mode == PR_MODE_HTTP) {
Vincent Bernat02779b62016-04-03 13:48:43 +0200384 node = calloc(1, sizeof(*node));
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100385 if (!node) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100386 memprintf(err, "out of memory error");
Dragan Dosen61302da2019-04-30 00:40:02 +0200387 goto error_free;
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100388 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100389 node->type = logformat_keywords[j].type;
390 node->options = *defoptions;
391 if (arg_len) {
392 node->arg = my_strndup(arg, arg_len);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100393 if (!parse_logformat_var_args(node->arg, node, err))
Dragan Dosen61302da2019-04-30 00:40:02 +0200394 goto error_free;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100395 }
396 if (node->type == LOG_FMT_GLOBAL) {
397 *defoptions = node->options;
398 free(node->arg);
399 free(node);
400 } else {
401 if (logformat_keywords[j].config_callback &&
402 logformat_keywords[j].config_callback(node, curproxy) != 0) {
Dragan Dosen61302da2019-04-30 00:40:02 +0200403 goto error_free;
William Lallemand723b73a2012-02-08 16:37:49 +0100404 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100405 curproxy->to_log |= logformat_keywords[j].lw;
406 LIST_ADDQ(list_format, &node->list);
William Lallemand723b73a2012-02-08 16:37:49 +0100407 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100408 if (logformat_keywords[j].replace_by)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100409 ha_warning("parsing [%s:%d] : deprecated variable '%s' in '%s', please replace it with '%s'.\n",
410 curproxy->conf.args.file, curproxy->conf.args.line,
411 logformat_keywords[j].name, fmt_directive(curproxy), logformat_keywords[j].replace_by);
Thierry FOURNIER / OZON.IOeca4d952016-11-22 22:06:04 +0100412 return 1;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100413 } else {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100414 memprintf(err, "format variable '%s' is reserved for HTTP mode",
415 logformat_keywords[j].name);
Dragan Dosen61302da2019-04-30 00:40:02 +0200416 goto error_free;
William Lallemand723b73a2012-02-08 16:37:49 +0100417 }
William Lallemand723b73a2012-02-08 16:37:49 +0100418 }
419 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100420
421 j = var[var_len];
422 var[var_len] = 0;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100423 memprintf(err, "no such format variable '%s'. If you wanted to emit the '%%' character verbatim, you need to use '%%%%'", var);
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100424 var[var_len] = j;
Dragan Dosen61302da2019-04-30 00:40:02 +0200425
426 error_free:
427 if (node) {
428 free(node->arg);
429 free(node);
430 }
Thierry FOURNIER / OZON.IOeca4d952016-11-22 22:06:04 +0100431 return 0;
William Lallemand723b73a2012-02-08 16:37:49 +0100432}
433
434/*
435 * push to the logformat linked list
436 *
437 * start: start pointer
438 * end: end text pointer
439 * type: string type
William Lallemand1d705562012-03-12 12:46:41 +0100440 * list_format: destination list
William Lallemand723b73a2012-02-08 16:37:49 +0100441 *
442 * LOG_TEXT: copy chars from start to end excluding end.
443 *
444*/
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100445int add_to_logformat_list(char *start, char *end, int type, struct list *list_format, char **err)
William Lallemand723b73a2012-02-08 16:37:49 +0100446{
447 char *str;
448
Willy Tarreaua3571662012-12-20 21:59:12 +0100449 if (type == LF_TEXT) { /* type text */
Vincent Bernat02779b62016-04-03 13:48:43 +0200450 struct logformat_node *node = calloc(1, sizeof(*node));
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100451 if (!node) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100452 memprintf(err, "out of memory error");
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100453 return 0;
454 }
Vincent Bernat02779b62016-04-03 13:48:43 +0200455 str = calloc(1, end - start + 1);
William Lallemand723b73a2012-02-08 16:37:49 +0100456 strncpy(str, start, end - start);
William Lallemand723b73a2012-02-08 16:37:49 +0100457 str[end - start] = '\0';
458 node->arg = str;
William Lallemand1d705562012-03-12 12:46:41 +0100459 node->type = LOG_FMT_TEXT; // type string
460 LIST_ADDQ(list_format, &node->list);
Willy Tarreaua3571662012-12-20 21:59:12 +0100461 } else if (type == LF_SEPARATOR) {
Vincent Bernat02779b62016-04-03 13:48:43 +0200462 struct logformat_node *node = calloc(1, sizeof(*node));
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100463 if (!node) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100464 memprintf(err, "out of memory error");
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100465 return 0;
466 }
William Lallemand1d705562012-03-12 12:46:41 +0100467 node->type = LOG_FMT_SEPARATOR;
468 LIST_ADDQ(list_format, &node->list);
William Lallemand723b73a2012-02-08 16:37:49 +0100469 }
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100470 return 1;
William Lallemand723b73a2012-02-08 16:37:49 +0100471}
472
473/*
Willy Tarreauc8368452012-12-21 00:09:23 +0100474 * Parse the sample fetch expression <text> and add a node to <list_format> upon
475 * success. At the moment, sample converters are not yet supported but fetch arguments
Willy Tarreaucd0d2ed2020-02-14 17:33:06 +0100476 * should work. The curpx->conf.args.ctx must be set by the caller. If an end pointer
477 * is passed in <endptr>, it will be updated with the pointer to the first character
478 * not part of the sample expression.
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100479 *
480 * In error case, the function returns 0, otherwise it returns 1.
Willy Tarreauc8368452012-12-21 00:09:23 +0100481 */
Willy Tarreaucd0d2ed2020-02-14 17:33:06 +0100482int add_sample_to_logformat_list(char *text, char *arg, int arg_len, struct proxy *curpx, struct list *list_format, int options, int cap, char **err, char **endptr)
Willy Tarreauc8368452012-12-21 00:09:23 +0100483{
484 char *cmd[2];
Dragan Dosen61302da2019-04-30 00:40:02 +0200485 struct sample_expr *expr = NULL;
486 struct logformat_node *node = NULL;
Willy Tarreauc8368452012-12-21 00:09:23 +0100487 int cmd_arg;
488
489 cmd[0] = text;
490 cmd[1] = "";
491 cmd_arg = 0;
492
Willy Tarreaucd0d2ed2020-02-14 17:33:06 +0100493 expr = sample_parse_expr(cmd, &cmd_arg, curpx->conf.args.file, curpx->conf.args.line, err, &curpx->conf.args, endptr);
Willy Tarreauc8368452012-12-21 00:09:23 +0100494 if (!expr) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100495 memprintf(err, "failed to parse sample expression <%s> : %s", text, *err);
Dragan Dosen61302da2019-04-30 00:40:02 +0200496 goto error_free;
Willy Tarreauc8368452012-12-21 00:09:23 +0100497 }
498
Vincent Bernat02779b62016-04-03 13:48:43 +0200499 node = calloc(1, sizeof(*node));
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100500 if (!node) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100501 memprintf(err, "out of memory error");
Dragan Dosen61302da2019-04-30 00:40:02 +0200502 goto error_free;
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100503 }
Willy Tarreauc8368452012-12-21 00:09:23 +0100504 node->type = LOG_FMT_EXPR;
505 node->expr = expr;
506 node->options = options;
507
508 if (arg_len) {
509 node->arg = my_strndup(arg, arg_len);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100510 if (!parse_logformat_var_args(node->arg, node, err))
Dragan Dosen61302da2019-04-30 00:40:02 +0200511 goto error_free;
Willy Tarreauc8368452012-12-21 00:09:23 +0100512 }
Willy Tarreau434c57c2013-01-08 01:10:24 +0100513 if (expr->fetch->val & cap & SMP_VAL_REQUEST)
Willy Tarreauc8368452012-12-21 00:09:23 +0100514 node->options |= LOG_OPT_REQ_CAP; /* fetch method is request-compatible */
515
Willy Tarreau434c57c2013-01-08 01:10:24 +0100516 if (expr->fetch->val & cap & SMP_VAL_RESPONSE)
Willy Tarreauc8368452012-12-21 00:09:23 +0100517 node->options |= LOG_OPT_RES_CAP; /* fetch method is response-compatible */
518
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100519 if (!(expr->fetch->val & cap)) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100520 memprintf(err, "sample fetch <%s> may not be reliably used here because it needs '%s' which is not available here",
521 text, sample_src_names(expr->fetch->use));
Dragan Dosen61302da2019-04-30 00:40:02 +0200522 goto error_free;
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100523 }
Willy Tarreau434c57c2013-01-08 01:10:24 +0100524
Christopher Faulet711ed6a2019-07-16 14:16:10 +0200525 /* check if we need to allocate an http_txn struct for HTTP parsing */
Willy Tarreauc8368452012-12-21 00:09:23 +0100526 /* Note, we may also need to set curpx->to_log with certain fetches */
Willy Tarreau25320b22013-03-24 07:22:08 +0100527 curpx->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
Willy Tarreauc8368452012-12-21 00:09:23 +0100528
William Lallemand65ad6e12014-01-31 15:08:02 +0100529 /* FIXME: temporary workaround for missing LW_XPRT and LW_REQ flags
530 * needed with some sample fetches (eg: ssl*). We always set it for
531 * now on, but this will leave with sample capabilities soon.
Willy Tarreau1f31c732013-01-10 16:22:27 +0100532 */
533 curpx->to_log |= LW_XPRT;
William Lallemand65ad6e12014-01-31 15:08:02 +0100534 curpx->to_log |= LW_REQ;
Willy Tarreauc8368452012-12-21 00:09:23 +0100535 LIST_ADDQ(list_format, &node->list);
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100536 return 1;
Dragan Dosen61302da2019-04-30 00:40:02 +0200537
538 error_free:
539 release_sample_expr(expr);
540 if (node) {
541 free(node->arg);
542 free(node);
543 }
544 return 0;
Willy Tarreauc8368452012-12-21 00:09:23 +0100545}
546
547/*
William Lallemand723b73a2012-02-08 16:37:49 +0100548 * Parse the log_format string and fill a linked list.
549 * Variable name are preceded by % and composed by characters [a-zA-Z0-9]* : %varname
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200550 * You can set arguments using { } : %{many arguments}varname.
551 * The curproxy->conf.args.ctx must be set by the caller.
William Lallemand1d705562012-03-12 12:46:41 +0100552 *
553 * str: the string to parse
554 * curproxy: the proxy affected
555 * list_format: the destination list
Willy Tarreau6cbbdbf2013-02-05 18:52:25 +0100556 * options: LOG_OPT_* to force on every node
Willy Tarreau434c57c2013-01-08 01:10:24 +0100557 * cap: all SMP_VAL_* flags supported by the consumer
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100558 *
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100559 * The function returns 1 in success case, otherwise, it returns 0 and err is filled.
William Lallemand723b73a2012-02-08 16:37:49 +0100560 */
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100561int parse_logformat_string(const char *fmt, struct proxy *curproxy, struct list *list_format, int options, int cap, char **err)
William Lallemand723b73a2012-02-08 16:37:49 +0100562{
Willy Tarreaub83bc1e2012-12-24 12:36:33 +0100563 char *sp, *str, *backfmt; /* start pointer for text parts */
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100564 char *arg = NULL; /* start pointer for args */
565 char *var = NULL; /* start pointer for vars */
566 int arg_len = 0;
567 int var_len = 0;
568 int cformat; /* current token format */
569 int pformat; /* previous token format */
William Lallemand723b73a2012-02-08 16:37:49 +0100570 struct logformat_node *tmplf, *back;
571
Willy Tarreaub83bc1e2012-12-24 12:36:33 +0100572 sp = str = backfmt = strdup(fmt);
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100573 if (!str) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100574 memprintf(err, "out of memory error");
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100575 return 0;
576 }
William Lallemand1dc00ef2012-08-09 16:41:35 +0200577 curproxy->to_log |= LW_INIT;
William Lallemand5e19a282012-04-02 16:22:10 +0200578
William Lallemand723b73a2012-02-08 16:37:49 +0100579 /* flush the list first. */
William Lallemand1d705562012-03-12 12:46:41 +0100580 list_for_each_entry_safe(tmplf, back, list_format, list) {
William Lallemand723b73a2012-02-08 16:37:49 +0100581 LIST_DEL(&tmplf->list);
Dragan Dosen61302da2019-04-30 00:40:02 +0200582 release_sample_expr(tmplf->expr);
583 free(tmplf->arg);
William Lallemand723b73a2012-02-08 16:37:49 +0100584 free(tmplf);
585 }
586
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100587 for (cformat = LF_INIT; cformat != LF_END; str++) {
William Lallemand723b73a2012-02-08 16:37:49 +0100588 pformat = cformat;
589
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100590 if (!*str)
591 cformat = LF_END; // preset it to save all states from doing this
William Lallemand723b73a2012-02-08 16:37:49 +0100592
Joseph Herlant85b40592018-11-15 12:10:04 -0800593 /* The principle of the two-step state machine below is to first detect a change, and
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100594 * second have all common paths processed at one place. The common paths are the ones
595 * encountered in text areas (LF_INIT, LF_TEXT, LF_SEPARATOR) and at the end (LF_END).
596 * We use the common LF_INIT state to dispatch to the different final states.
597 */
598 switch (pformat) {
599 case LF_STARTVAR: // text immediately following a '%'
Willy Tarreauc8368452012-12-21 00:09:23 +0100600 arg = NULL; var = NULL;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100601 arg_len = var_len = 0;
602 if (*str == '{') { // optional argument
603 cformat = LF_STARG;
604 arg = str + 1;
William Lallemand723b73a2012-02-08 16:37:49 +0100605 }
Willy Tarreauc8368452012-12-21 00:09:23 +0100606 else if (*str == '[') {
607 cformat = LF_STEXPR;
608 var = str + 1; // store expr in variable name
609 }
Willy Tarreau0f28f822013-12-16 01:38:33 +0100610 else if (isalpha((unsigned char)*str)) { // variable name
William Lallemand723b73a2012-02-08 16:37:49 +0100611 cformat = LF_VAR;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100612 var = str;
William Lallemand723b73a2012-02-08 16:37:49 +0100613 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100614 else if (*str == '%')
615 cformat = LF_TEXT; // convert this character to a litteral (useful for '%')
Willy Tarreau0f28f822013-12-16 01:38:33 +0100616 else if (isdigit((unsigned char)*str) || *str == ' ' || *str == '\t') {
Willy Tarreau06d97f92013-12-02 17:45:48 +0100617 /* single '%' followed by blank or digit, send them both */
618 cformat = LF_TEXT;
619 pformat = LF_TEXT; /* finally we include the previous char as well */
620 sp = str - 1; /* send both the '%' and the current char */
Jim Freemana2278c82017-04-15 08:01:59 -0600621 memprintf(err, "unexpected variable name near '%c' at position %d line : '%s'. Maybe you want to write a single '%%', use the syntax '%%%%'",
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100622 *str, (int)(str - backfmt), fmt);
Willy Tarreau51013e82019-12-11 12:05:39 +0100623 goto fail;
Willy Tarreau06d97f92013-12-02 17:45:48 +0100624
625 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100626 else
627 cformat = LF_INIT; // handle other cases of litterals
628 break;
629
630 case LF_STARG: // text immediately following '%{'
631 if (*str == '}') { // end of arg
William Lallemand723b73a2012-02-08 16:37:49 +0100632 cformat = LF_EDARG;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100633 arg_len = str - arg;
634 *str = 0; // used for reporting errors
William Lallemand723b73a2012-02-08 16:37:49 +0100635 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100636 break;
637
638 case LF_EDARG: // text immediately following '%{arg}'
Willy Tarreauc8368452012-12-21 00:09:23 +0100639 if (*str == '[') {
640 cformat = LF_STEXPR;
641 var = str + 1; // store expr in variable name
642 break;
643 }
Willy Tarreau0f28f822013-12-16 01:38:33 +0100644 else if (isalnum((unsigned char)*str)) { // variable name
William Lallemand723b73a2012-02-08 16:37:49 +0100645 cformat = LF_VAR;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100646 var = str;
647 break;
648 }
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100649 memprintf(err, "parse argument modifier without variable name near '%%{%s}'", arg);
Willy Tarreau51013e82019-12-11 12:05:39 +0100650 goto fail;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100651
Willy Tarreauc8368452012-12-21 00:09:23 +0100652 case LF_STEXPR: // text immediately following '%['
Willy Tarreaucd0d2ed2020-02-14 17:33:06 +0100653 /* the whole sample expression is parsed at once,
654 * returning the pointer to the first character not
655 * part of the expression, which MUST be the trailing
656 * angle bracket.
657 */
658 if (!add_sample_to_logformat_list(var, arg, arg_len, curproxy, list_format, options, cap, err, &str))
659 goto fail;
660
661 if (*str == ']') {
662 // end of arg, go on with next state
663 cformat = pformat = LF_EDEXPR;
664 sp = str;
665 }
666 else {
667 char c = *str;
668 *str = 0;
Willy Tarreau90807112020-02-25 08:16:33 +0100669 if (isprint((unsigned char)c))
Willy Tarreaucd0d2ed2020-02-14 17:33:06 +0100670 memprintf(err, "expected ']' after '%s', but found '%c'", var, c);
671 else
672 memprintf(err, "missing ']' after '%s'", var);
Willy Tarreauc8368452012-12-21 00:09:23 +0100673 }
674 break;
675
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100676 case LF_VAR: // text part of a variable name
677 var_len = str - var;
Willy Tarreau0f28f822013-12-16 01:38:33 +0100678 if (!isalnum((unsigned char)*str))
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100679 cformat = LF_INIT; // not variable name anymore
680 break;
681
Willy Tarreauc8368452012-12-21 00:09:23 +0100682 default: // LF_INIT, LF_TEXT, LF_SEPARATOR, LF_END, LF_EDEXPR
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100683 cformat = LF_INIT;
684 }
685
686 if (cformat == LF_INIT) { /* resynchronize state to text/sep/startvar */
687 switch (*str) {
688 case '%': cformat = LF_STARTVAR; break;
689 case ' ': cformat = LF_SEPARATOR; break;
690 case 0 : cformat = LF_END; break;
691 default : cformat = LF_TEXT; break;
William Lallemand723b73a2012-02-08 16:37:49 +0100692 }
693 }
694
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100695 if (cformat != pformat || pformat == LF_SEPARATOR) {
696 switch (pformat) {
697 case LF_VAR:
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100698 if (!parse_logformat_var(arg, arg_len, var, var_len, curproxy, list_format, &options, err))
Willy Tarreau51013e82019-12-11 12:05:39 +0100699 goto fail;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100700 break;
Willy Tarreauc8368452012-12-21 00:09:23 +0100701 case LF_STEXPR:
Willy Tarreaucd0d2ed2020-02-14 17:33:06 +0100702 if (!add_sample_to_logformat_list(var, arg, arg_len, curproxy, list_format, options, cap, err, &sp))
Willy Tarreau51013e82019-12-11 12:05:39 +0100703 goto fail;
Willy Tarreauc8368452012-12-21 00:09:23 +0100704 break;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100705 case LF_TEXT:
706 case LF_SEPARATOR:
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100707 if (!add_to_logformat_list(sp, str, pformat, list_format, err))
Willy Tarreau51013e82019-12-11 12:05:39 +0100708 goto fail;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100709 break;
710 }
711 sp = str; /* new start of text at every state switch and at every separator */
William Lallemand723b73a2012-02-08 16:37:49 +0100712 }
713 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100714
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100715 if (pformat == LF_STARTVAR || pformat == LF_STARG || pformat == LF_STEXPR) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100716 memprintf(err, "truncated line after '%s'", var ? var : arg ? arg : "%");
Willy Tarreau51013e82019-12-11 12:05:39 +0100717 goto fail;
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100718 }
Willy Tarreaub83bc1e2012-12-24 12:36:33 +0100719 free(backfmt);
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100720
721 return 1;
Willy Tarreau51013e82019-12-11 12:05:39 +0100722 fail:
723 free(backfmt);
724 return 0;
William Lallemand723b73a2012-02-08 16:37:49 +0100725}
726
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200727/*
Frédéric Lécailled95ea282019-04-24 16:14:33 +0200728 * Parse the first range of indexes from a string made of a list of comma seperated
729 * ranges of indexes. Note that an index may be considered as a particular range
730 * with a high limit to the low limit.
731 */
732int get_logsrv_smp_range(unsigned int *low, unsigned int *high, char **arg, char **err)
733{
734 char *end, *p;
735
736 *low = *high = 0;
737
738 p = *arg;
739 end = strchr(p, ',');
740 if (!end)
741 end = p + strlen(p);
742
743 *high = *low = read_uint((const char **)&p, end);
744 if (!*low || (p != end && *p != '-'))
745 goto err;
746
747 if (p == end)
748 goto done;
749
750 p++;
751 *high = read_uint((const char **)&p, end);
752 if (!*high || *high <= *low || p != end)
753 goto err;
754
755 done:
756 if (*end == ',')
757 end++;
758 *arg = end;
759 return 1;
760
761 err:
762 memprintf(err, "wrong sample range '%s'", *arg);
763 return 0;
764}
765
766/*
767 * Returns 1 if the range defined by <low> and <high> overlaps
768 * one of them in <rgs> array of ranges with <sz> the size of this
769 * array, 0 if not.
770 */
771int smp_log_ranges_overlap(struct smp_log_range *rgs, size_t sz,
772 unsigned int low, unsigned int high, char **err)
773{
774 size_t i;
775
776 for (i = 0; i < sz; i++) {
777 if ((low >= rgs[i].low && low <= rgs[i].high) ||
778 (high >= rgs[i].low && high <= rgs[i].high)) {
779 memprintf(err, "ranges are overlapping");
780 return 1;
781 }
782 }
783
784 return 0;
785}
786
787int smp_log_range_cmp(const void *a, const void *b)
788{
789 const struct smp_log_range *rg_a = a;
790 const struct smp_log_range *rg_b = b;
791
792 if (rg_a->high < rg_b->low)
793 return -1;
794 else if (rg_a->low > rg_b->high)
795 return 1;
796
797 return 0;
798}
799
800/*
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200801 * Parse "log" keyword and update <logsrvs> list accordingly.
802 *
803 * When <do_del> is set, it means the "no log" line was parsed, so all log
804 * servers in <logsrvs> are released.
805 *
806 * Otherwise, we try to parse the "log" line. First of all, when the list is not
807 * the global one, we look for the parameter "global". If we find it,
808 * global.logsrvs is copied. Else we parse each arguments.
809 *
810 * The function returns 1 in success case, otherwise, it returns 0 and err is
811 * filled.
812 */
813int parse_logsrv(char **args, struct list *logsrvs, int do_del, char **err)
814{
815 struct sockaddr_storage *sk;
816 struct logsrv *logsrv = NULL;
817 int port1, port2;
818 int cur_arg;
819
820 /*
821 * "no log": delete previous herited or defined syslog
822 * servers.
823 */
824 if (do_del) {
825 struct logsrv *back;
826
827 if (*(args[1]) != 0) {
828 memprintf(err, "'no log' does not expect arguments");
829 goto error;
830 }
831
832 list_for_each_entry_safe(logsrv, back, logsrvs, list) {
833 LIST_DEL(&logsrv->list);
834 free(logsrv);
835 }
836 return 1;
837 }
838
839 /*
840 * "log global": copy global.logrsvs linked list to the end of logsrvs
841 * list. But first, we check (logsrvs != global.logsrvs).
842 */
843 if (*(args[1]) && *(args[2]) == 0 && !strcmp(args[1], "global")) {
844 if (logsrvs == &global.logsrvs) {
845 memprintf(err, "'global' is not supported for a global syslog server");
846 goto error;
847 }
848 list_for_each_entry(logsrv, &global.logsrvs, list) {
Christopher Faulet28ac0992018-03-26 16:09:19 +0200849 struct logsrv *node;
850
851 list_for_each_entry(node, logsrvs, list) {
852 if (node->ref == logsrv)
853 goto skip_logsrv;
854 }
855
856 node = malloc(sizeof(*node));
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200857 memcpy(node, logsrv, sizeof(struct logsrv));
Christopher Faulet28ac0992018-03-26 16:09:19 +0200858 node->ref = logsrv;
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200859 LIST_INIT(&node->list);
860 LIST_ADDQ(logsrvs, &node->list);
Christopher Faulet28ac0992018-03-26 16:09:19 +0200861
862 skip_logsrv:
863 continue;
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200864 }
865 return 1;
866 }
867
868 /*
869 * "log <address> ...: parse a syslog server line
870 */
871 if (*(args[1]) == 0 || *(args[2]) == 0) {
872 memprintf(err, "expects <address> and <facility> %s as arguments",
873 ((logsrvs == &global.logsrvs) ? "" : "or global"));
874 goto error;
875 }
876
Willy Tarreau5a32ecc2018-11-12 07:34:59 +0100877 /* take care of "stdout" and "stderr" as regular aliases for fd@1 / fd@2 */
878 if (strcmp(args[1], "stdout") == 0)
879 args[1] = "fd@1";
880 else if (strcmp(args[1], "stderr") == 0)
881 args[1] = "fd@2";
882
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200883 logsrv = calloc(1, sizeof(*logsrv));
884 if (!logsrv) {
885 memprintf(err, "out of memory");
886 goto error;
887 }
888
889 /* skip address for now, it will be parsed at the end */
890 cur_arg = 2;
891
892 /* just after the address, a length may be specified */
893 logsrv->maxlen = MAX_SYSLOG_LEN;
894 if (strcmp(args[cur_arg], "len") == 0) {
895 int len = atoi(args[cur_arg+1]);
896 if (len < 80 || len > 65535) {
897 memprintf(err, "invalid log length '%s', must be between 80 and 65535",
898 args[cur_arg+1]);
899 goto error;
900 }
901 logsrv->maxlen = len;
902 cur_arg += 2;
903 }
904 if (logsrv->maxlen > global.max_syslog_len)
905 global.max_syslog_len = logsrv->maxlen;
906
907 /* after the length, a format may be specified */
908 if (strcmp(args[cur_arg], "format") == 0) {
909 logsrv->format = get_log_format(args[cur_arg+1]);
910 if (logsrv->format < 0) {
911 memprintf(err, "unknown log format '%s'", args[cur_arg+1]);
912 goto error;
913 }
914 cur_arg += 2;
915 }
916
Frédéric Lécailled95ea282019-04-24 16:14:33 +0200917 if (strcmp(args[cur_arg], "sample") == 0) {
918 unsigned low, high;
919 char *p, *beg, *end, *smp_sz_str;
920 struct smp_log_range *smp_rgs = NULL;
921 size_t smp_rgs_sz = 0, smp_sz = 0, new_smp_sz;
922
923 p = args[cur_arg+1];
924 smp_sz_str = strchr(p, ':');
925 if (!smp_sz_str) {
926 memprintf(err, "Missing sample size");
927 goto error;
928 }
929
930 *smp_sz_str++ = '\0';
931
932 end = p + strlen(p);
933
934 while (p != end) {
935 if (!get_logsrv_smp_range(&low, &high, &p, err))
936 goto error;
937
938 if (smp_rgs && smp_log_ranges_overlap(smp_rgs, smp_rgs_sz, low, high, err))
939 goto error;
940
941 smp_rgs = my_realloc2(smp_rgs, (smp_rgs_sz + 1) * sizeof *smp_rgs);
942 if (!smp_rgs) {
943 memprintf(err, "out of memory error");
944 goto error;
945 }
946
947 smp_rgs[smp_rgs_sz].low = low;
948 smp_rgs[smp_rgs_sz].high = high;
949 smp_rgs[smp_rgs_sz].sz = high - low + 1;
950 smp_rgs[smp_rgs_sz].curr_idx = 0;
951 if (smp_rgs[smp_rgs_sz].high > smp_sz)
952 smp_sz = smp_rgs[smp_rgs_sz].high;
953 smp_rgs_sz++;
954 }
955
Tim Duesterhus21648002019-06-23 22:10:10 +0200956 if (smp_rgs == NULL) {
957 memprintf(err, "no sampling ranges given");
958 goto error;
959 }
960
Frédéric Lécailled95ea282019-04-24 16:14:33 +0200961 beg = smp_sz_str;
962 end = beg + strlen(beg);
963 new_smp_sz = read_uint((const char **)&beg, end);
964 if (!new_smp_sz || beg != end) {
965 memprintf(err, "wrong sample size '%s' for sample range '%s'",
966 smp_sz_str, args[cur_arg+1]);
967 goto error;
968 }
969
970 if (new_smp_sz < smp_sz) {
971 memprintf(err, "sample size %zu should be greater or equal to "
972 "%zu the maximum of the high ranges limits",
973 new_smp_sz, smp_sz);
974 goto error;
975 }
976 smp_sz = new_smp_sz;
977
978 /* Let's order <smp_rgs> array. */
979 qsort(smp_rgs, smp_rgs_sz, sizeof(struct smp_log_range), smp_log_range_cmp);
980
981 logsrv->lb.smp_rgs = smp_rgs;
982 logsrv->lb.smp_rgs_sz = smp_rgs_sz;
983 logsrv->lb.smp_sz = smp_sz;
984
985 cur_arg += 2;
986 }
Frédéric Lécailled803e472019-04-25 07:42:09 +0200987 HA_SPIN_INIT(&logsrv->lock);
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200988 /* parse the facility */
989 logsrv->facility = get_log_facility(args[cur_arg]);
990 if (logsrv->facility < 0) {
991 memprintf(err, "unknown log facility '%s'", args[cur_arg]);
992 goto error;
993 }
994 cur_arg++;
995
996 /* parse the max syslog level (default: debug) */
997 logsrv->level = 7;
998 if (*(args[cur_arg])) {
999 logsrv->level = get_log_level(args[cur_arg]);
1000 if (logsrv->level < 0) {
1001 memprintf(err, "unknown optional log level '%s'", args[cur_arg]);
1002 goto error;
1003 }
1004 cur_arg++;
1005 }
1006
1007 /* parse the limit syslog level (default: emerg) */
1008 logsrv->minlvl = 0;
1009 if (*(args[cur_arg])) {
1010 logsrv->minlvl = get_log_level(args[cur_arg]);
1011 if (logsrv->minlvl < 0) {
1012 memprintf(err, "unknown optional minimum log level '%s'", args[cur_arg]);
1013 goto error;
1014 }
1015 cur_arg++;
1016 }
1017
1018 /* Too many args */
1019 if (*(args[cur_arg])) {
1020 memprintf(err, "cannot handle unexpected argument '%s'", args[cur_arg]);
1021 goto error;
1022 }
1023
1024 /* now, back to the address */
Willy Tarreauf3dc30f2019-08-30 14:18:44 +02001025 logsrv->type = LOG_TARGET_DGRAM;
Willy Tarreauc046d162019-08-30 15:24:59 +02001026 if (strncmp(args[1], "ring@", 5) == 0) {
1027 struct sink *sink = sink_find(args[1] + 5);
1028
1029 if (!sink || sink->type != SINK_TYPE_BUFFER) {
1030 memprintf(err, "cannot find ring buffer '%s'", args[1] + 5);
1031 goto error;
1032 }
1033
1034 logsrv->addr.ss_family = AF_UNSPEC;
1035 logsrv->type = LOG_TARGET_BUFFER;
1036 logsrv->ring = sink->ctx.ring;
1037 goto done;
1038 }
1039
Willy Tarreauf3dc30f2019-08-30 14:18:44 +02001040 if (strncmp(args[1], "fd@", 3) == 0)
1041 logsrv->type = LOG_TARGET_FD;
1042
Christopher Faulet4b0b79d2018-03-26 15:54:32 +02001043 sk = str2sa_range(args[1], NULL, &port1, &port2, err, NULL, NULL, 1);
1044 if (!sk)
1045 goto error;
1046 logsrv->addr = *sk;
1047
1048 if (sk->ss_family == AF_INET || sk->ss_family == AF_INET6) {
1049 if (port1 != port2) {
1050 memprintf(err, "port ranges and offsets are not allowed in '%s'", args[1]);
1051 goto error;
1052 }
1053 logsrv->addr = *sk;
1054 if (!port1)
1055 set_host_port(&logsrv->addr, SYSLOG_PORT);
1056 }
Willy Tarreauc046d162019-08-30 15:24:59 +02001057 done:
Christopher Faulet4b0b79d2018-03-26 15:54:32 +02001058 LIST_ADDQ(logsrvs, &logsrv->list);
1059 return 1;
1060
1061 error:
1062 free(logsrv);
1063 return 0;
1064}
1065
1066
Christopher Fauletd4696382017-10-24 11:44:05 +02001067/* Generic function to display messages prefixed by a label */
1068static void print_message(const char *label, const char *fmt, va_list argp)
1069{
1070 struct tm tm;
1071 char *head, *msg;
1072
1073 head = msg = NULL;
1074
1075 get_localtime(date.tv_sec, &tm);
1076 memprintf(&head, "[%s] %03d/%02d%02d%02d (%d) : ",
1077 label, tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec, (int)getpid());
1078 memvprintf(&msg, fmt, argp);
1079
Willy Tarreau869efd52019-11-15 15:16:57 +01001080 if (global.mode & MODE_STARTING) {
1081 if (unlikely(!startup_logs))
1082 startup_logs = ring_new(STARTUP_LOG_SIZE);
1083
1084 if (likely(startup_logs)) {
1085 struct ist m[2];
1086
1087 m[0] = ist(head);
1088 m[1] = ist(msg);
1089 /* trim the trailing '\n' */
1090 if (m[1].len > 0 && m[1].ptr[m[1].len - 1] == '\n')
1091 m[1].len--;
1092 ring_write(startup_logs, ~0, 0, 0, m, 2);
1093 }
1094 }
Christopher Fauletd4696382017-10-24 11:44:05 +02001095
1096 fprintf(stderr, "%s%s", head, msg);
1097 fflush(stderr);
1098
1099 free(head);
1100 free(msg);
1101}
1102
Willy Tarreaubaaee002006-06-26 02:48:02 +02001103/*
1104 * Displays the message on stderr with the date and pid. Overrides the quiet
1105 * mode during startup.
1106 */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001107void ha_alert(const char *fmt, ...)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001108{
1109 va_list argp;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001110
1111 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
1112 va_start(argp, fmt);
Christopher Fauletd4696382017-10-24 11:44:05 +02001113 print_message("ALERT", fmt, argp);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001114 va_end(argp);
1115 }
1116}
1117
1118
1119/*
1120 * Displays the message on stderr with the date and pid.
1121 */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001122void ha_warning(const char *fmt, ...)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001123{
1124 va_list argp;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001125
1126 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
1127 va_start(argp, fmt);
Christopher Fauletd4696382017-10-24 11:44:05 +02001128 print_message("WARNING", fmt, argp);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001129 va_end(argp);
1130 }
1131}
1132
1133/*
William Lallemand9c56a222018-11-21 18:04:52 +01001134 * Displays the message on stderr with the date and pid.
1135 */
1136void ha_notice(const char *fmt, ...)
1137{
1138 va_list argp;
1139
1140 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
1141 va_start(argp, fmt);
1142 print_message("NOTICE", fmt, argp);
1143 va_end(argp);
1144 }
1145}
1146
1147/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001148 * Displays the message on <out> only if quiet mode is not set.
1149 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001150void qfprintf(FILE *out, const char *fmt, ...)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001151{
1152 va_list argp;
1153
1154 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
1155 va_start(argp, fmt);
1156 vfprintf(out, fmt, argp);
1157 fflush(out);
1158 va_end(argp);
1159 }
1160}
1161
1162/*
Dragan Dosen1322d092015-09-22 16:05:32 +02001163 * returns log format for <fmt> or -1 if not found.
1164 */
1165int get_log_format(const char *fmt)
1166{
1167 int format;
1168
1169 format = LOG_FORMATS - 1;
Dragan Dosen43885c72015-10-01 13:18:13 +02001170 while (format >= 0 && strcmp(log_formats[format].name, fmt))
Dragan Dosen1322d092015-09-22 16:05:32 +02001171 format--;
1172
1173 return format;
1174}
1175
1176/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001177 * returns log level for <lev> or -1 if not found.
1178 */
1179int get_log_level(const char *lev)
1180{
1181 int level;
1182
1183 level = NB_LOG_LEVELS - 1;
1184 while (level >= 0 && strcmp(log_levels[level], lev))
1185 level--;
1186
1187 return level;
1188}
1189
Willy Tarreaubaaee002006-06-26 02:48:02 +02001190/*
1191 * returns log facility for <fac> or -1 if not found.
1192 */
1193int get_log_facility(const char *fac)
1194{
1195 int facility;
1196
1197 facility = NB_LOG_FACILITIES - 1;
1198 while (facility >= 0 && strcmp(log_facilities[facility], fac))
1199 facility--;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001200
Willy Tarreaubaaee002006-06-26 02:48:02 +02001201 return facility;
1202}
1203
William Lallemanda1cc3812012-02-08 16:38:44 +01001204/*
Dragan Dosen835b9212016-02-12 13:23:03 +01001205 * Encode the string.
1206 *
1207 * When using the +E log format option, it will try to escape '"\]'
1208 * characters with '\' as prefix. The same prefix should not be used as
1209 * <escape>.
1210 */
1211static char *lf_encode_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001212 const char escape, const long *map,
Dragan Dosen835b9212016-02-12 13:23:03 +01001213 const char *string,
1214 struct logformat_node *node)
1215{
1216 if (node->options & LOG_OPT_ESC) {
1217 if (start < stop) {
1218 stop--; /* reserve one byte for the final '\0' */
1219 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001220 if (!ha_bit_test((unsigned char)(*string), map)) {
1221 if (!ha_bit_test((unsigned char)(*string), rfc5424_escape_map))
Dragan Dosen835b9212016-02-12 13:23:03 +01001222 *start++ = *string;
1223 else {
1224 if (start + 2 >= stop)
1225 break;
1226 *start++ = '\\';
1227 *start++ = *string;
1228 }
1229 }
1230 else {
1231 if (start + 3 >= stop)
1232 break;
1233 *start++ = escape;
1234 *start++ = hextab[(*string >> 4) & 15];
1235 *start++ = hextab[*string & 15];
1236 }
1237 string++;
1238 }
1239 *start = '\0';
1240 }
1241 }
1242 else {
1243 return encode_string(start, stop, escape, map, string);
1244 }
1245
1246 return start;
1247}
1248
1249/*
1250 * Encode the chunk.
1251 *
1252 * When using the +E log format option, it will try to escape '"\]'
1253 * characters with '\' as prefix. The same prefix should not be used as
1254 * <escape>.
1255 */
1256static char *lf_encode_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001257 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001258 const struct buffer *chunk,
Dragan Dosen835b9212016-02-12 13:23:03 +01001259 struct logformat_node *node)
1260{
1261 char *str, *end;
1262
1263 if (node->options & LOG_OPT_ESC) {
1264 if (start < stop) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001265 str = chunk->area;
1266 end = chunk->area + chunk->data;
Dragan Dosen835b9212016-02-12 13:23:03 +01001267
1268 stop--; /* reserve one byte for the final '\0' */
1269 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001270 if (!ha_bit_test((unsigned char)(*str), map)) {
1271 if (!ha_bit_test((unsigned char)(*str), rfc5424_escape_map))
Dragan Dosen835b9212016-02-12 13:23:03 +01001272 *start++ = *str;
1273 else {
1274 if (start + 2 >= stop)
1275 break;
1276 *start++ = '\\';
1277 *start++ = *str;
1278 }
1279 }
1280 else {
1281 if (start + 3 >= stop)
1282 break;
1283 *start++ = escape;
1284 *start++ = hextab[(*str >> 4) & 15];
1285 *start++ = hextab[*str & 15];
1286 }
1287 str++;
1288 }
1289 *start = '\0';
1290 }
1291 }
1292 else {
1293 return encode_chunk(start, stop, escape, map, chunk);
1294 }
1295
1296 return start;
1297}
1298
1299/*
William Lallemanda1cc3812012-02-08 16:38:44 +01001300 * Write a string in the log string
Dragan Dosen835b9212016-02-12 13:23:03 +01001301 * Take cares of quote and escape options
William Lallemanda1cc3812012-02-08 16:38:44 +01001302 *
Joseph Herlant85b40592018-11-15 12:10:04 -08001303 * Return the address of the \0 character, or NULL on error
William Lallemanda1cc3812012-02-08 16:38:44 +01001304 */
Willy Tarreau26ffa852018-09-05 15:23:10 +02001305char *lf_text_len(char *dst, const char *src, size_t len, size_t size, const struct logformat_node *node)
William Lallemanda1cc3812012-02-08 16:38:44 +01001306{
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001307 if (size < 2)
1308 return NULL;
William Lallemanda1cc3812012-02-08 16:38:44 +01001309
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001310 if (node->options & LOG_OPT_QUOTE) {
1311 *(dst++) = '"';
1312 size--;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001313 }
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001314
Willy Tarreau6cbbdbf2013-02-05 18:52:25 +01001315 if (src && len) {
Dragan Dosendb1b6f92016-07-25 11:35:02 +02001316 if (++len > size)
1317 len = size;
Dragan Dosen835b9212016-02-12 13:23:03 +01001318 if (node->options & LOG_OPT_ESC) {
Dragan Dosen835b9212016-02-12 13:23:03 +01001319 char *ret;
1320
Dragan Dosendb1b6f92016-07-25 11:35:02 +02001321 ret = escape_string(dst, dst + len, '\\', rfc5424_escape_map, src);
Dragan Dosen835b9212016-02-12 13:23:03 +01001322 if (ret == NULL || *ret != '\0')
1323 return NULL;
1324 len = ret - dst;
1325 }
1326 else {
Dragan Dosen835b9212016-02-12 13:23:03 +01001327 len = strlcpy2(dst, src, len);
1328 }
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001329
1330 size -= len;
1331 dst += len;
1332 }
Willy Tarreau6cbbdbf2013-02-05 18:52:25 +01001333 else if ((node->options & (LOG_OPT_QUOTE|LOG_OPT_MANDATORY)) == LOG_OPT_MANDATORY) {
1334 if (size < 2)
1335 return NULL;
1336 *(dst++) = '-';
1337 }
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001338
1339 if (node->options & LOG_OPT_QUOTE) {
1340 if (size < 2)
1341 return NULL;
1342 *(dst++) = '"';
1343 }
1344
1345 *dst = '\0';
William Lallemandbddd4fd2012-02-27 11:23:10 +01001346 return dst;
William Lallemanda1cc3812012-02-08 16:38:44 +01001347}
1348
Willy Tarreau26ffa852018-09-05 15:23:10 +02001349static inline char *lf_text(char *dst, const char *src, size_t size, const struct logformat_node *node)
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001350{
1351 return lf_text_len(dst, src, size, size, node);
1352}
1353
William Lallemand5f232402012-04-05 18:02:55 +02001354/*
Joseph Herlant85b40592018-11-15 12:10:04 -08001355 * Write a IP address to the log string
William Lallemand5f232402012-04-05 18:02:55 +02001356 * +X option write in hexadecimal notation, most signifant byte on the left
1357 */
Willy Tarreau26ffa852018-09-05 15:23:10 +02001358char *lf_ip(char *dst, const struct sockaddr *sockaddr, size_t size, const struct logformat_node *node)
William Lallemand5f232402012-04-05 18:02:55 +02001359{
1360 char *ret = dst;
1361 int iret;
1362 char pn[INET6_ADDRSTRLEN];
1363
1364 if (node->options & LOG_OPT_HEXA) {
Radek Zajic594c4562019-03-22 10:21:54 +00001365 unsigned char *addr = NULL;
1366 switch (sockaddr->sa_family) {
1367 case AF_INET:
1368 addr = (unsigned char *)&((struct sockaddr_in *)sockaddr)->sin_addr.s_addr;
1369 iret = snprintf(dst, size, "%02X%02X%02X%02X", addr[0], addr[1], addr[2], addr[3]);
1370 break;
1371 case AF_INET6:
1372 addr = (unsigned char *)&((struct sockaddr_in6 *)sockaddr)->sin6_addr.s6_addr;
1373 iret = snprintf(dst, size, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
1374 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
1375 addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15]);
1376 break;
1377 default:
1378 return NULL;
1379 }
William Lallemand5f232402012-04-05 18:02:55 +02001380 if (iret < 0 || iret > size)
1381 return NULL;
1382 ret += iret;
1383 } else {
1384 addr_to_str((struct sockaddr_storage *)sockaddr, pn, sizeof(pn));
1385 ret = lf_text(dst, pn, size, node);
1386 if (ret == NULL)
1387 return NULL;
1388 }
1389 return ret;
1390}
1391
1392/*
1393 * Write a port to the log
1394 * +X option write in hexadecimal notation, most signifant byte on the left
1395 */
Willy Tarreau26ffa852018-09-05 15:23:10 +02001396char *lf_port(char *dst, const struct sockaddr *sockaddr, size_t size, const struct logformat_node *node)
William Lallemand5f232402012-04-05 18:02:55 +02001397{
1398 char *ret = dst;
1399 int iret;
1400
1401 if (node->options & LOG_OPT_HEXA) {
1402 const unsigned char *port = (const unsigned char *)&((struct sockaddr_in *)sockaddr)->sin_port;
1403 iret = snprintf(dst, size, "%02X%02X", port[0], port[1]);
1404 if (iret < 0 || iret > size)
1405 return NULL;
1406 ret += iret;
1407 } else {
1408 ret = ltoa_o(get_host_port((struct sockaddr_storage *)sockaddr), dst, size);
1409 if (ret == NULL)
1410 return NULL;
1411 }
1412 return ret;
1413}
1414
Dragan Dosen1322d092015-09-22 16:05:32 +02001415/* Re-generate time-based part of the syslog header in RFC3164 format at
1416 * the beginning of logheader once a second and return the pointer to the
1417 * first character after it.
Willy Tarreaub1a2faf2012-03-19 16:51:53 +01001418 */
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001419static char *update_log_hdr(const time_t time)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001420{
Christopher Fauletf8188c62017-06-02 16:20:16 +02001421 static THREAD_LOCAL long tvsec;
Willy Tarreau83061a82018-07-13 11:56:34 +02001422 static THREAD_LOCAL struct buffer host = { };
Christopher Fauletf8188c62017-06-02 16:20:16 +02001423 static THREAD_LOCAL int sep = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001424
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001425 if (unlikely(time != tvsec || logheader_end == NULL)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001426 /* this string is rebuild only once a second */
Willy Tarreaufe944602007-10-25 10:34:16 +02001427 struct tm tm;
Willy Tarreaub1a2faf2012-03-19 16:51:53 +01001428 int hdr_len;
Willy Tarreaufe944602007-10-25 10:34:16 +02001429
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001430 tvsec = time;
Willy Tarreaufe944602007-10-25 10:34:16 +02001431 get_localtime(tvsec, &tm);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001432
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001433 if (unlikely(global.log_send_hostname != host.area)) {
1434 host.area = global.log_send_hostname;
1435 host.data = host.area ? strlen(host.area) : 0;
1436 sep = host.data ? 1 : 0;
Dragan Dosen43885c72015-10-01 13:18:13 +02001437 }
1438
Dragan Dosen59cee972015-09-19 22:09:02 +02001439 hdr_len = snprintf(logheader, global.max_syslog_len,
Dragan Dosen43885c72015-10-01 13:18:13 +02001440 "<<<<>%s %2d %02d:%02d:%02d %.*s%*s",
Willy Tarreaufe944602007-10-25 10:34:16 +02001441 monthname[tm.tm_mon],
Dragan Dosen43885c72015-10-01 13:18:13 +02001442 tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001443 (int)host.data, host.area, sep, "");
Willy Tarreaubaaee002006-06-26 02:48:02 +02001444 /* WARNING: depending upon implementations, snprintf may return
1445 * either -1 or the number of bytes that would be needed to store
1446 * the total message. In both cases, we must adjust it.
1447 */
Willy Tarreau18324f52014-06-27 18:10:07 +02001448 if (hdr_len < 0 || hdr_len > global.max_syslog_len)
1449 hdr_len = global.max_syslog_len;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001450
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001451 logheader_end = logheader + hdr_len;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001452 }
1453
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001454 logheader_end[0] = 0; // ensure we get rid of any previous attempt
Willy Tarreau094af4e2015-01-07 15:03:42 +01001455
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001456 return logheader_end;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001457}
1458
Dragan Dosen1322d092015-09-22 16:05:32 +02001459/* Re-generate time-based part of the syslog header in RFC5424 format at
1460 * the beginning of logheader_rfc5424 once a second and return the pointer
1461 * to the first character after it.
1462 */
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001463static char *update_log_hdr_rfc5424(const time_t time)
Dragan Dosen1322d092015-09-22 16:05:32 +02001464{
Christopher Fauletf8188c62017-06-02 16:20:16 +02001465 static THREAD_LOCAL long tvsec;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001466 const char *gmt_offset;
Dragan Dosen1322d092015-09-22 16:05:32 +02001467
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001468 if (unlikely(time != tvsec || logheader_rfc5424_end == NULL)) {
Dragan Dosen1322d092015-09-22 16:05:32 +02001469 /* this string is rebuild only once a second */
1470 struct tm tm;
1471 int hdr_len;
1472
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001473 tvsec = time;
Dragan Dosen1322d092015-09-22 16:05:32 +02001474 get_localtime(tvsec, &tm);
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001475 gmt_offset = get_gmt_offset(time, &tm);
Dragan Dosen1322d092015-09-22 16:05:32 +02001476
1477 hdr_len = snprintf(logheader_rfc5424, global.max_syslog_len,
Dragan Dosen17def462015-10-09 21:31:43 +02001478 "<<<<>1 %4d-%02d-%02dT%02d:%02d:%02d%.3s:%.2s %s ",
Dragan Dosen1322d092015-09-22 16:05:32 +02001479 tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
Dragan Dosen17def462015-10-09 21:31:43 +02001480 tm.tm_hour, tm.tm_min, tm.tm_sec,
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001481 gmt_offset, gmt_offset+3,
Dragan Dosen43885c72015-10-01 13:18:13 +02001482 global.log_send_hostname ? global.log_send_hostname : hostname);
Dragan Dosen1322d092015-09-22 16:05:32 +02001483 /* WARNING: depending upon implementations, snprintf may return
1484 * either -1 or the number of bytes that would be needed to store
1485 * the total message. In both cases, we must adjust it.
1486 */
1487 if (hdr_len < 0 || hdr_len > global.max_syslog_len)
1488 hdr_len = global.max_syslog_len;
1489
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001490 logheader_rfc5424_end = logheader_rfc5424 + hdr_len;
Dragan Dosen1322d092015-09-22 16:05:32 +02001491 }
1492
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001493 logheader_rfc5424_end[0] = 0; // ensure we get rid of any previous attempt
Dragan Dosen1322d092015-09-22 16:05:32 +02001494
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001495 return logheader_rfc5424_end;
Dragan Dosen1322d092015-09-22 16:05:32 +02001496}
1497
William Lallemand2a4a44f2012-02-06 16:00:33 +01001498/*
Dragan Dosen59cee972015-09-19 22:09:02 +02001499 * This function sends the syslog message using a printf format string. It
1500 * expects an LF-terminated message.
William Lallemand2a4a44f2012-02-06 16:00:33 +01001501 */
1502void send_log(struct proxy *p, int level, const char *format, ...)
1503{
1504 va_list argp;
Willy Tarreaub1a2faf2012-03-19 16:51:53 +01001505 int data_len;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001506
Willy Tarreau8c97ab52015-01-15 16:29:53 +01001507 if (level < 0 || format == NULL || logline == NULL)
William Lallemand2a4a44f2012-02-06 16:00:33 +01001508 return;
1509
William Lallemand2a4a44f2012-02-06 16:00:33 +01001510 va_start(argp, format);
Dragan Dosen59cee972015-09-19 22:09:02 +02001511 data_len = vsnprintf(logline, global.max_syslog_len, format, argp);
Willy Tarreau18324f52014-06-27 18:10:07 +02001512 if (data_len < 0 || data_len > global.max_syslog_len)
1513 data_len = global.max_syslog_len;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001514 va_end(argp);
William Lallemand2a4a44f2012-02-06 16:00:33 +01001515
Christopher Faulet5c6fefc2019-08-11 19:40:12 +02001516 __send_log((p ? &p->logsrvs : NULL), (p ? &p->log_tag : NULL), level,
1517 logline, data_len, default_rfc5424_sd_log_format, 2);
William Lallemand2a4a44f2012-02-06 16:00:33 +01001518}
1519
1520/*
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001521 * This function sends a syslog message to <logsrv>.
1522 * <pid_str> is the string to be used for the PID of the caller, <pid_size> is length.
1523 * Same thing for <sd> and <sd_size> which are used for the structured-data part
1524 * in RFC5424 formatted syslog messages, and <tag_str> and <tag_size> the syslog tag.
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001525 * It overrides the last byte of the message vector with an LF character.
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001526 * Does not return any error,
William Lallemand2a4a44f2012-02-06 16:00:33 +01001527 */
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001528static inline void __do_send_log(struct logsrv *logsrv, int nblogger, char *pid_str, size_t pid_size,
1529 int level, char *message, size_t size, char *sd, size_t sd_size,
1530 char *tag_str, size_t tag_size)
William Lallemand2a4a44f2012-02-06 16:00:33 +01001531{
Christopher Fauletf8188c62017-06-02 16:20:16 +02001532 static THREAD_LOCAL struct iovec iovec[NB_MSG_IOVEC_ELEMENTS] = { };
1533 static THREAD_LOCAL struct msghdr msghdr = {
1534 //.msg_iov = iovec,
Dragan Dosen609ac2a2015-09-16 18:25:42 +02001535 .msg_iovlen = NB_MSG_IOVEC_ELEMENTS
1536 };
Christopher Fauletf8188c62017-06-02 16:20:16 +02001537 static THREAD_LOCAL int logfdunix = -1; /* syslog to AF_UNIX socket */
1538 static THREAD_LOCAL int logfdinet = -1; /* syslog to AF_INET socket */
1539 static THREAD_LOCAL char *dataptr = NULL;
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001540 time_t time = date.tv_sec;
Dragan Dosen1322d092015-09-22 16:05:32 +02001541 char *hdr, *hdr_ptr;
Dragan Dosen59cee972015-09-19 22:09:02 +02001542 size_t hdr_size;
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001543 int fac_level;
1544 int *plogfd;
1545 char *pid_sep1 = "", *pid_sep2 = "";
1546 char logheader_short[3];
1547 int sent;
1548 int maxlen;
1549 int hdr_max = 0;
1550 int tag_max = 0;
1551 int pid_sep1_max = 0;
Frédéric Lécaille90a10ae2019-05-14 10:57:58 +02001552 int pid_max = 0;
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001553 int pid_sep2_max = 0;
1554 int sd_max = 0;
1555 int max = 0;
Christopher Fauletf8188c62017-06-02 16:20:16 +02001556
1557 msghdr.msg_iov = iovec;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001558
1559 dataptr = message;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001560
Willy Tarreauf3dc30f2019-08-30 14:18:44 +02001561 if (logsrv->type == LOG_TARGET_FD) {
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001562 /* the socket's address is a file descriptor */
1563 plogfd = (int *)&((struct sockaddr_in *)&logsrv->addr)->sin_addr.s_addr;
Robert Tsai81ae1952007-12-05 10:47:29 +01001564 }
Willy Tarreauc046d162019-08-30 15:24:59 +02001565 else if (logsrv->type == LOG_TARGET_BUFFER) {
1566 plogfd = NULL;
1567 }
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001568 else if (logsrv->addr.ss_family == AF_UNIX)
1569 plogfd = &logfdunix;
1570 else
1571 plogfd = &logfdinet;
Robert Tsai81ae1952007-12-05 10:47:29 +01001572
Willy Tarreauc046d162019-08-30 15:24:59 +02001573 if (plogfd && unlikely(*plogfd < 0)) {
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001574 /* socket not successfully initialized yet */
1575 if ((*plogfd = socket(logsrv->addr.ss_family, SOCK_DGRAM,
1576 (logsrv->addr.ss_family == AF_UNIX) ? 0 : IPPROTO_UDP)) < 0) {
1577 static char once;
William Lallemand0f99e342011-10-12 17:50:54 +02001578
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001579 if (!once) {
1580 once = 1; /* note: no need for atomic ops here */
1581 ha_alert("socket() failed in logger #%d: %s (errno=%d)\n",
1582 nblogger, strerror(errno), errno);
1583 }
1584 return;
1585 } else {
1586 /* we don't want to receive anything on this socket */
1587 setsockopt(*plogfd, SOL_SOCKET, SO_RCVBUF, &zero, sizeof(zero));
1588 /* does nothing under Linux, maybe needed for others */
1589 shutdown(*plogfd, SHUT_RD);
1590 fcntl(*plogfd, F_SETFD, fcntl(*plogfd, F_GETFD, FD_CLOEXEC) | FD_CLOEXEC);
1591 }
Dragan Dosen43885c72015-10-01 13:18:13 +02001592 }
1593
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001594 switch (logsrv->format) {
1595 case LOG_FORMAT_RFC3164:
1596 hdr = logheader;
1597 hdr_ptr = update_log_hdr(time);
1598 break;
Willy Tarreauc7c7be22014-06-23 18:07:15 +02001599
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001600 case LOG_FORMAT_RFC5424:
1601 hdr = logheader_rfc5424;
1602 hdr_ptr = update_log_hdr_rfc5424(time);
1603 sd_max = sd_size; /* the SD part allowed only in RFC5424 */
1604 break;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001605
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001606 case LOG_FORMAT_SHORT:
1607 /* all fields are known, skip the header generation */
1608 hdr = logheader_short;
1609 hdr[0] = '<';
1610 hdr[1] = '0' + MAX(level, logsrv->minlvl);
1611 hdr[2] = '>';
1612 hdr_ptr = hdr;
1613 hdr_max = 3;
1614 maxlen = logsrv->maxlen - hdr_max;
1615 max = MIN(size, maxlen) - 1;
1616 goto send;
Willy Tarreau204e3f12018-12-15 15:48:48 +01001617
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001618 case LOG_FORMAT_RAW:
1619 /* all fields are known, skip the header generation */
1620 hdr_ptr = hdr = "";
1621 hdr_max = 0;
1622 maxlen = logsrv->maxlen;
1623 max = MIN(size, maxlen) - 1;
1624 goto send;
Willy Tarreauc98aebc2018-03-20 11:17:29 +01001625
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001626 default:
1627 return; /* must never happen */
1628 }
Willy Tarreauc7c7be22014-06-23 18:07:15 +02001629
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001630 hdr_size = hdr_ptr - hdr;
Dragan Dosen1322d092015-09-22 16:05:32 +02001631
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001632 /* For each target, we may have a different facility.
1633 * We can also have a different log level for each message.
1634 * This induces variations in the message header length.
1635 * Since we don't want to recompute it each time, nor copy it every
1636 * time, we only change the facility in the pre-computed header,
1637 * and we change the pointer to the header accordingly.
1638 */
1639 fac_level = (logsrv->facility << 3) + MAX(level, logsrv->minlvl);
1640 hdr_ptr = hdr + 3; /* last digit of the log level */
1641 do {
1642 *hdr_ptr = '0' + fac_level % 10;
1643 fac_level /= 10;
1644 hdr_ptr--;
1645 } while (fac_level && hdr_ptr > hdr);
1646 *hdr_ptr = '<';
Dragan Dosen1322d092015-09-22 16:05:32 +02001647
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001648 hdr_max = hdr_size - (hdr_ptr - hdr);
Willy Tarreaue8746a02018-11-12 08:45:00 +01001649
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001650 /* time-based header */
1651 if (unlikely(hdr_size >= logsrv->maxlen)) {
1652 hdr_max = MIN(hdr_max, logsrv->maxlen) - 1;
1653 sd_max = 0;
1654 goto send;
1655 }
Willy Tarreauc1b06452018-11-12 11:57:56 +01001656
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001657 maxlen = logsrv->maxlen - hdr_max;
Dragan Dosen1322d092015-09-22 16:05:32 +02001658
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001659 /* tag */
Frédéric Lécaille90a10ae2019-05-14 10:57:58 +02001660 tag_max = tag_size;
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001661 if (unlikely(tag_max >= maxlen)) {
1662 tag_max = maxlen - 1;
1663 sd_max = 0;
1664 goto send;
1665 }
Dragan Dosen1322d092015-09-22 16:05:32 +02001666
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001667 maxlen -= tag_max;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001668
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001669 /* first pid separator */
1670 pid_sep1_max = log_formats[logsrv->format].pid.sep1.data;
1671 if (unlikely(pid_sep1_max >= maxlen)) {
1672 pid_sep1_max = maxlen - 1;
1673 sd_max = 0;
1674 goto send;
1675 }
Dragan Dosen59cee972015-09-19 22:09:02 +02001676
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001677 pid_sep1 = log_formats[logsrv->format].pid.sep1.area;
1678 maxlen -= pid_sep1_max;
Dragan Dosen59cee972015-09-19 22:09:02 +02001679
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001680 /* pid */
Frédéric Lécaille90a10ae2019-05-14 10:57:58 +02001681 pid_max = pid_size;
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001682 if (unlikely(pid_size >= maxlen)) {
1683 pid_size = maxlen - 1;
1684 sd_max = 0;
1685 goto send;
1686 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02001687
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001688 maxlen -= pid_size;
Dragan Dosen43885c72015-10-01 13:18:13 +02001689
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001690 /* second pid separator */
1691 pid_sep2_max = log_formats[logsrv->format].pid.sep2.data;
1692 if (unlikely(pid_sep2_max >= maxlen)) {
1693 pid_sep2_max = maxlen - 1;
1694 sd_max = 0;
1695 goto send;
1696 }
Dragan Dosen43885c72015-10-01 13:18:13 +02001697
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001698 pid_sep2 = log_formats[logsrv->format].pid.sep2.area;
1699 maxlen -= pid_sep2_max;
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02001700
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001701 /* structured-data */
1702 if (sd_max >= maxlen) {
1703 sd_max = maxlen - 1;
1704 goto send;
1705 }
Dragan Dosen59cee972015-09-19 22:09:02 +02001706
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001707 max = MIN(size, maxlen - sd_max) - 1;
1708send:
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001709 if (logsrv->addr.ss_family == AF_UNSPEC) {
Willy Tarreauc046d162019-08-30 15:24:59 +02001710 /* the target is a file descriptor or a ring buffer */
Willy Tarreaud52a7f82019-08-30 14:05:35 +02001711 struct ist msg[7];
1712
1713 msg[0].ptr = hdr_ptr; msg[0].len = hdr_max;
1714 msg[1].ptr = tag_str; msg[1].len = tag_max;
1715 msg[2].ptr = pid_sep1; msg[2].len = pid_sep1_max;
1716 msg[3].ptr = pid_str; msg[3].len = pid_max;
1717 msg[4].ptr = pid_sep2; msg[4].len = pid_sep2_max;
1718 msg[5].ptr = sd; msg[5].len = sd_max;
1719 msg[6].ptr = dataptr; msg[6].len = max;
1720
Willy Tarreauc046d162019-08-30 15:24:59 +02001721 if (logsrv->type == LOG_TARGET_BUFFER)
1722 sent = ring_write(logsrv->ring, ~0, NULL, 0, msg, 7);
1723 else /* LOG_TARGET_FD */
1724 sent = fd_write_frag_line(*plogfd, ~0, NULL, 0, msg, 7, 1);
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001725 }
1726 else {
Willy Tarreaud52a7f82019-08-30 14:05:35 +02001727 iovec[0].iov_base = hdr_ptr;
1728 iovec[0].iov_len = hdr_max;
1729 iovec[1].iov_base = tag_str;
1730 iovec[1].iov_len = tag_max;
1731 iovec[2].iov_base = pid_sep1;
1732 iovec[2].iov_len = pid_sep1_max;
1733 iovec[3].iov_base = pid_str;
1734 iovec[3].iov_len = pid_max;
1735 iovec[4].iov_base = pid_sep2;
1736 iovec[4].iov_len = pid_sep2_max;
1737 iovec[5].iov_base = sd;
1738 iovec[5].iov_len = sd_max;
1739 iovec[6].iov_base = dataptr;
1740 iovec[6].iov_len = max;
1741 iovec[7].iov_base = "\n"; /* insert a \n at the end of the message */
1742 iovec[7].iov_len = 1;
1743
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001744 msghdr.msg_name = (struct sockaddr *)&logsrv->addr;
1745 msghdr.msg_namelen = get_addr_len(&logsrv->addr);
Dragan Dosen43885c72015-10-01 13:18:13 +02001746
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001747 sent = sendmsg(*plogfd, &msghdr, MSG_DONTWAIT | MSG_NOSIGNAL);
1748 }
Dragan Dosen43885c72015-10-01 13:18:13 +02001749
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001750 if (sent < 0) {
1751 static char once;
Dragan Dosen43885c72015-10-01 13:18:13 +02001752
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001753 if (errno == EAGAIN)
1754 _HA_ATOMIC_ADD(&dropped_logs, 1);
1755 else if (!once) {
1756 once = 1; /* note: no need for atomic ops here */
1757 ha_alert("sendmsg()/writev() failed in logger #%d: %s (errno=%d)\n",
1758 nblogger, strerror(errno), errno);
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001759 }
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001760 }
1761}
Dragan Dosen59cee972015-09-19 22:09:02 +02001762
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001763/*
1764 * This function sends a syslog message.
1765 * It doesn't care about errors nor does it report them.
1766 * The arguments <sd> and <sd_size> are used for the structured-data part
1767 * in RFC5424 formatted syslog messages.
1768 */
Christopher Faulet5c6fefc2019-08-11 19:40:12 +02001769void __send_log(struct list *logsrvs, struct buffer *tag, int level,
1770 char *message, size_t size, char *sd, size_t sd_size)
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001771{
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001772 struct logsrv *logsrv;
1773 int nblogger;
1774 static THREAD_LOCAL int curr_pid;
1775 static THREAD_LOCAL char pidstr[100];
1776 static THREAD_LOCAL struct buffer pid;
Dragan Dosen609ac2a2015-09-16 18:25:42 +02001777
Christopher Faulet5c6fefc2019-08-11 19:40:12 +02001778 if (logsrvs == NULL) {
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001779 if (!LIST_ISEMPTY(&global.logsrvs)) {
1780 logsrvs = &global.logsrvs;
Willy Tarreau5a32ecc2018-11-12 07:34:59 +01001781 }
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001782 }
Christopher Faulet5c6fefc2019-08-11 19:40:12 +02001783 if (!tag || !tag->area)
1784 tag = &global.log_tag;
Willy Tarreau18324f52014-06-27 18:10:07 +02001785
Christopher Faulet5c6fefc2019-08-11 19:40:12 +02001786 if (!logsrvs || LIST_ISEMPTY(logsrvs))
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001787 return;
Willy Tarreauc98aebc2018-03-20 11:17:29 +01001788
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001789 if (unlikely(curr_pid != getpid())) {
1790 curr_pid = getpid();
1791 ltoa_o(curr_pid, pidstr, sizeof(pidstr));
1792 chunk_initstr(&pid, pidstr);
1793 }
1794
1795 /* Send log messages to syslog server. */
1796 nblogger = 0;
1797 list_for_each_entry(logsrv, logsrvs, list) {
Frédéric Lécailled803e472019-04-25 07:42:09 +02001798 static THREAD_LOCAL int in_range = 1;
1799
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001800 /* we can filter the level of the messages that are sent to each logger */
1801 if (level > logsrv->level)
1802 continue;
1803
Frédéric Lécailled803e472019-04-25 07:42:09 +02001804 if (logsrv->lb.smp_rgs) {
1805 struct smp_log_range *curr_rg;
1806
1807 HA_SPIN_LOCK(LOGSRV_LOCK, &logsrv->lock);
1808 curr_rg = &logsrv->lb.smp_rgs[logsrv->lb.curr_rg];
1809 in_range = in_smp_log_range(curr_rg, logsrv->lb.curr_idx);
1810 if (in_range) {
1811 /* Let's consume this range. */
1812 curr_rg->curr_idx = (curr_rg->curr_idx + 1) % curr_rg->sz;
1813 if (!curr_rg->curr_idx) {
1814 /* If consumed, let's select the next range. */
1815 logsrv->lb.curr_rg = (logsrv->lb.curr_rg + 1) % logsrv->lb.smp_rgs_sz;
1816 }
1817 }
1818 logsrv->lb.curr_idx = (logsrv->lb.curr_idx + 1) % logsrv->lb.smp_sz;
1819 HA_SPIN_UNLOCK(LOGSRV_LOCK, &logsrv->lock);
1820 }
1821 if (in_range)
1822 __do_send_log(logsrv, ++nblogger, pid.area, pid.data, level,
1823 message, size, sd, sd_size, tag->area, tag->data);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001824 }
1825}
1826
1827
Willy Tarreauc89ccb62012-04-05 21:18:22 +02001828const char sess_cookie[8] = "NIDVEOU7"; /* No cookie, Invalid cookie, cookie for a Down server, Valid cookie, Expired cookie, Old cookie, Unused, unknown */
William Lallemandbddd4fd2012-02-27 11:23:10 +01001829const char sess_set_cookie[8] = "NPDIRU67"; /* No set-cookie, Set-cookie found and left unchanged (passive),
1830 Set-cookie Deleted, Set-Cookie Inserted, Set-cookie Rewritten,
1831 Set-cookie Updated, unknown, unknown */
1832
William Lallemand1d705562012-03-12 12:46:41 +01001833/*
1834 * try to write a character if there is enough space, or goto out
1835 */
William Lallemandbddd4fd2012-02-27 11:23:10 +01001836#define LOGCHAR(x) do { \
William Lallemand1d705562012-03-12 12:46:41 +01001837 if (tmplog < dst + maxsize - 1) { \
William Lallemandbddd4fd2012-02-27 11:23:10 +01001838 *(tmplog++) = (x); \
1839 } else { \
1840 goto out; \
1841 } \
1842 } while(0)
1843
Dragan Dosen835b9212016-02-12 13:23:03 +01001844
Willy Tarreaub6b3df32018-11-26 16:31:20 +01001845/* Initializes some log data at boot */
1846static void init_log()
Dragan Dosen835b9212016-02-12 13:23:03 +01001847{
1848 char *tmp;
Willy Tarreaue10cd482018-09-10 18:16:53 +02001849 int i;
Dragan Dosen835b9212016-02-12 13:23:03 +01001850
1851 /* Initialize the escape map for the RFC5424 structured-data : '"\]'
1852 * inside PARAM-VALUE should be escaped with '\' as prefix.
1853 * See https://tools.ietf.org/html/rfc5424#section-6.3.3 for more
1854 * details.
1855 */
1856 memset(rfc5424_escape_map, 0, sizeof(rfc5424_escape_map));
1857
1858 tmp = "\"\\]";
1859 while (*tmp) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001860 ha_bit_set(*tmp, rfc5424_escape_map);
Dragan Dosen835b9212016-02-12 13:23:03 +01001861 tmp++;
1862 }
Willy Tarreaue10cd482018-09-10 18:16:53 +02001863
1864 /* initialize the log header encoding map : '{|}"#' should be encoded with
1865 * '#' as prefix, as well as non-printable characters ( <32 or >= 127 ).
1866 * URL encoding only requires '"', '#' to be encoded as well as non-
1867 * printable characters above.
1868 */
1869 memset(hdr_encode_map, 0, sizeof(hdr_encode_map));
1870 memset(url_encode_map, 0, sizeof(url_encode_map));
1871 for (i = 0; i < 32; i++) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001872 ha_bit_set(i, hdr_encode_map);
1873 ha_bit_set(i, url_encode_map);
Willy Tarreaue10cd482018-09-10 18:16:53 +02001874 }
1875 for (i = 127; i < 256; i++) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001876 ha_bit_set(i, hdr_encode_map);
1877 ha_bit_set(i, url_encode_map);
Willy Tarreaue10cd482018-09-10 18:16:53 +02001878 }
1879
1880 tmp = "\"#{|}";
1881 while (*tmp) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001882 ha_bit_set(*tmp, hdr_encode_map);
Willy Tarreaue10cd482018-09-10 18:16:53 +02001883 tmp++;
1884 }
1885
1886 tmp = "\"#";
1887 while (*tmp) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001888 ha_bit_set(*tmp, url_encode_map);
Willy Tarreaue10cd482018-09-10 18:16:53 +02001889 tmp++;
1890 }
1891
1892 /* initialize the http header encoding map. The draft httpbis define the
1893 * header content as:
1894 *
1895 * HTTP-message = start-line
1896 * *( header-field CRLF )
1897 * CRLF
1898 * [ message-body ]
1899 * header-field = field-name ":" OWS field-value OWS
1900 * field-value = *( field-content / obs-fold )
1901 * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
1902 * obs-fold = CRLF 1*( SP / HTAB )
1903 * field-vchar = VCHAR / obs-text
1904 * VCHAR = %x21-7E
1905 * obs-text = %x80-FF
1906 *
1907 * All the chars are encoded except "VCHAR", "obs-text", SP and HTAB.
1908 * The encoded chars are form 0x00 to 0x08, 0x0a to 0x1f and 0x7f. The
Joseph Herlant85b40592018-11-15 12:10:04 -08001909 * "obs-fold" is voluntarily forgotten because haproxy remove this.
Willy Tarreaue10cd482018-09-10 18:16:53 +02001910 */
1911 memset(http_encode_map, 0, sizeof(http_encode_map));
1912 for (i = 0x00; i <= 0x08; i++)
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001913 ha_bit_set(i, http_encode_map);
Willy Tarreaue10cd482018-09-10 18:16:53 +02001914 for (i = 0x0a; i <= 0x1f; i++)
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001915 ha_bit_set(i, http_encode_map);
1916 ha_bit_set(0x7f, http_encode_map);
Dragan Dosen835b9212016-02-12 13:23:03 +01001917}
William Lallemand1d705562012-03-12 12:46:41 +01001918
Willy Tarreaub6b3df32018-11-26 16:31:20 +01001919INITCALL0(STG_PREPARE, init_log);
1920
Christopher Faulet0132d062017-07-26 15:33:35 +02001921/* Initialize log buffers used for syslog messages */
1922int init_log_buffers()
1923{
1924 logheader = my_realloc2(logheader, global.max_syslog_len + 1);
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001925 logheader_end = NULL;
Christopher Faulet0132d062017-07-26 15:33:35 +02001926 logheader_rfc5424 = my_realloc2(logheader_rfc5424, global.max_syslog_len + 1);
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001927 logheader_rfc5424_end = NULL;
Christopher Faulet0132d062017-07-26 15:33:35 +02001928 logline = my_realloc2(logline, global.max_syslog_len + 1);
1929 logline_rfc5424 = my_realloc2(logline_rfc5424, global.max_syslog_len + 1);
1930 if (!logheader || !logline_rfc5424 || !logline || !logline_rfc5424)
1931 return 0;
1932 return 1;
1933}
1934
1935/* Deinitialize log buffers used for syslog messages */
1936void deinit_log_buffers()
1937{
1938 free(logheader);
1939 free(logheader_rfc5424);
1940 free(logline);
1941 free(logline_rfc5424);
Willy Tarreau869efd52019-11-15 15:16:57 +01001942 ring_free(_HA_ATOMIC_XCHG(&startup_logs, NULL));
Christopher Faulet0132d062017-07-26 15:33:35 +02001943 logheader = NULL;
1944 logheader_rfc5424 = NULL;
1945 logline = NULL;
1946 logline_rfc5424 = NULL;
1947}
1948
Willy Tarreaudf974472012-12-28 02:44:01 +01001949/* Builds a log line in <dst> based on <list_format>, and stops before reaching
1950 * <maxsize> characters. Returns the size of the output string in characters,
1951 * not counting the trailing zero which is always added if the resulting size
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001952 * is not zero. It requires a valid session and optionally a stream. If the
1953 * stream is NULL, default values will be assumed for the stream part.
Willy Tarreaudf974472012-12-28 02:44:01 +01001954 */
Willy Tarreau43c538e2018-09-05 14:58:15 +02001955int sess_build_logline(struct session *sess, struct stream *s, char *dst, size_t maxsize, struct list *list_format)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001956{
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02001957 struct proxy *fe = sess->fe;
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001958 struct proxy *be;
1959 struct http_txn *txn;
1960 const struct strm_logs *logs;
Willy Tarreau8fa99842019-07-17 11:47:11 +02001961 struct connection *be_conn;
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001962 unsigned int s_flags;
1963 unsigned int uniq_id;
Willy Tarreau83061a82018-07-13 11:56:34 +02001964 struct buffer chunk;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001965 char *uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00001966 char *spc;
Andrew Hayworthe63ac872015-07-31 16:14:16 +00001967 char *qmark;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00001968 char *end;
Willy Tarreaufe944602007-10-25 10:34:16 +02001969 struct tm tm;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001970 int t_request;
1971 int hdr;
1972 int last_isspace = 1;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00001973 int nspaces = 0;
Willy Tarreaub1a2faf2012-03-19 16:51:53 +01001974 char *tmplog;
William Lallemand1d705562012-03-12 12:46:41 +01001975 char *ret;
1976 int iret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001977 struct logformat_node *tmp;
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02001978 struct timeval tv;
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001979 struct strm_logs tmp_strm_log;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001980
William Lallemandbddd4fd2012-02-27 11:23:10 +01001981 /* FIXME: let's limit ourselves to frontend logging for now. */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001982
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001983 if (likely(s)) {
1984 be = s->be;
1985 txn = s->txn;
1986 be_conn = cs_conn(objt_cs(s->si[1].end));
1987 s_flags = s->flags;
1988 uniq_id = s->uniq_id;
1989 logs = &s->logs;
1990 } else {
1991 /* we have no stream so we first need to initialize a few
1992 * things that are needed later. We do increment the request
1993 * ID so that it's uniquely assigned to this request just as
1994 * if the request had reached the point of being processed.
1995 * A request error is reported as it's the only element we have
1996 * here and which justifies emitting such a log.
1997 */
1998 be = fe;
1999 txn = NULL;
2000 be_conn = NULL;
2001 s_flags = SF_ERR_PRXCOND | SF_FINST_R;
Olivier Houchardd2ee3e72019-03-08 18:53:21 +01002002 uniq_id = _HA_ATOMIC_XADD(&global.req_count, 1);
Willy Tarreau09bb27c2018-09-05 16:55:15 +02002003
2004 /* prepare a valid log structure */
2005 tmp_strm_log.tv_accept = sess->tv_accept;
2006 tmp_strm_log.accept_date = sess->accept_date;
2007 tmp_strm_log.t_handshake = sess->t_handshake;
2008 tmp_strm_log.t_idle = tv_ms_elapsed(&sess->tv_accept, &now) - sess->t_handshake;
2009 tv_zero(&tmp_strm_log.tv_request);
2010 tmp_strm_log.t_queue = -1;
2011 tmp_strm_log.t_connect = -1;
2012 tmp_strm_log.t_data = -1;
2013 tmp_strm_log.t_close = tv_ms_elapsed(&sess->tv_accept, &now);
2014 tmp_strm_log.bytes_in = 0;
2015 tmp_strm_log.bytes_out = 0;
2016 tmp_strm_log.prx_queue_pos = 0;
2017 tmp_strm_log.srv_queue_pos = 0;
2018
2019 logs = &tmp_strm_log;
2020 }
2021
William Lallemandbddd4fd2012-02-27 11:23:10 +01002022 t_request = -1;
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002023 if (tv_isge(&logs->tv_request, &logs->tv_accept))
2024 t_request = tv_ms_elapsed(&logs->tv_accept, &logs->tv_request);
William Lallemandbddd4fd2012-02-27 11:23:10 +01002025
William Lallemand1d705562012-03-12 12:46:41 +01002026 tmplog = dst;
Willy Tarreauc9bd0cc2009-05-10 11:57:02 +02002027
William Lallemandbddd4fd2012-02-27 11:23:10 +01002028 /* fill logbuffer */
William Lallemand1d705562012-03-12 12:46:41 +01002029 if (LIST_ISEMPTY(list_format))
2030 return 0;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002031
William Lallemand1d705562012-03-12 12:46:41 +01002032 list_for_each_entry(tmp, list_format, list) {
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002033 struct connection *conn;
Willy Tarreau4f653562012-10-12 19:48:16 +02002034 const char *src = NULL;
Willy Tarreauc8368452012-12-21 00:09:23 +01002035 struct sample *key;
Willy Tarreau83061a82018-07-13 11:56:34 +02002036 const struct buffer empty = { };
William Lallemandbddd4fd2012-02-27 11:23:10 +01002037
Willy Tarreauc8368452012-12-21 00:09:23 +01002038 switch (tmp->type) {
William Lallemand1d705562012-03-12 12:46:41 +01002039 case LOG_FMT_SEPARATOR:
William Lallemandbddd4fd2012-02-27 11:23:10 +01002040 if (!last_isspace) {
2041 LOGCHAR(' ');
2042 last_isspace = 1;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002043 }
2044 break;
2045
William Lallemand1d705562012-03-12 12:46:41 +01002046 case LOG_FMT_TEXT: // text
William Lallemandbddd4fd2012-02-27 11:23:10 +01002047 src = tmp->arg;
William Lallemand5f232402012-04-05 18:02:55 +02002048 iret = strlcpy2(tmplog, src, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002049 if (iret == 0)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002050 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002051 tmplog += iret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002052 last_isspace = 0;
2053 break;
2054
Willy Tarreauc8368452012-12-21 00:09:23 +01002055 case LOG_FMT_EXPR: // sample expression, may be request or response
2056 key = NULL;
Olivier Houchardf90db442018-12-15 14:00:06 +01002057 if (tmp->options & LOG_OPT_REQ_CAP && s)
Adis Nezirovic79beb242015-07-06 15:41:02 +02002058 key = sample_fetch_as_type(be, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, tmp->expr, SMP_T_STR);
Olivier Houchardf90db442018-12-15 14:00:06 +01002059 if (!key && (tmp->options & LOG_OPT_RES_CAP) && s)
Adis Nezirovic79beb242015-07-06 15:41:02 +02002060 key = sample_fetch_as_type(be, sess, s, SMP_OPT_DIR_RES|SMP_OPT_FINAL, tmp->expr, SMP_T_STR);
Thierry FOURNIERd048d8b2014-03-13 16:46:18 +01002061 if (tmp->options & LOG_OPT_HTTP)
Dragan Dosen835b9212016-02-12 13:23:03 +01002062 ret = lf_encode_chunk(tmplog, dst + maxsize,
2063 '%', http_encode_map, key ? &key->data.u.str : &empty, tmp);
Thierry FOURNIERd048d8b2014-03-13 16:46:18 +01002064 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002065 ret = lf_text_len(tmplog,
2066 key ? key->data.u.str.area : NULL,
2067 key ? key->data.u.str.data : 0,
2068 dst + maxsize - tmplog,
2069 tmp);
Willy Tarreauc8368452012-12-21 00:09:23 +01002070 if (ret == 0)
2071 goto out;
2072 tmplog = ret;
2073 last_isspace = 0;
2074 break;
2075
Willy Tarreau2beef582012-12-20 17:22:52 +01002076 case LOG_FMT_CLIENTIP: // %ci
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002077 conn = objt_conn(sess->origin);
Willy Tarreau8fa99842019-07-17 11:47:11 +02002078 if (conn && conn_get_src(conn))
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002079 ret = lf_ip(tmplog, (struct sockaddr *)conn->src, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002080 else
2081 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002082 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002083 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002084 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002085 last_isspace = 0;
2086 break;
2087
Willy Tarreau2beef582012-12-20 17:22:52 +01002088 case LOG_FMT_CLIENTPORT: // %cp
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002089 conn = objt_conn(sess->origin);
Willy Tarreau8fa99842019-07-17 11:47:11 +02002090 if (conn && conn_get_src(conn)) {
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002091 if (conn->src->ss_family == AF_UNIX) {
Willy Tarreaufb0afa72015-04-03 14:46:27 +02002092 ret = ltoa_o(sess->listener->luid, tmplog, dst + maxsize - tmplog);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002093 } else {
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002094 ret = lf_port(tmplog, (struct sockaddr *)conn->src,
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002095 dst + maxsize - tmplog, tmp);
2096 }
William Lallemand5f232402012-04-05 18:02:55 +02002097 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002098 else
2099 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2100
William Lallemand5f232402012-04-05 18:02:55 +02002101 if (ret == NULL)
2102 goto out;
2103 tmplog = ret;
2104 last_isspace = 0;
2105 break;
2106
Willy Tarreau2beef582012-12-20 17:22:52 +01002107 case LOG_FMT_FRONTENDIP: // %fi
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002108 conn = objt_conn(sess->origin);
Willy Tarreau8fa99842019-07-17 11:47:11 +02002109 if (conn && conn_get_dst(conn)) {
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002110 ret = lf_ip(tmplog, (struct sockaddr *)conn->dst, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002111 }
2112 else
2113 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2114
William Lallemand1d705562012-03-12 12:46:41 +01002115 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002116 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002117 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002118 last_isspace = 0;
2119 break;
2120
Willy Tarreau2beef582012-12-20 17:22:52 +01002121 case LOG_FMT_FRONTENDPORT: // %fp
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002122 conn = objt_conn(sess->origin);
Willy Tarreau8fa99842019-07-17 11:47:11 +02002123 if (conn && conn_get_dst(conn)) {
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002124 if (conn->dst->ss_family == AF_UNIX)
Willy Tarreaufb0afa72015-04-03 14:46:27 +02002125 ret = ltoa_o(sess->listener->luid, tmplog, dst + maxsize - tmplog);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002126 else
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002127 ret = lf_port(tmplog, (struct sockaddr *)conn->dst, dst + maxsize - tmplog, tmp);
William Lallemand5f232402012-04-05 18:02:55 +02002128 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002129 else
2130 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2131
William Lallemand5f232402012-04-05 18:02:55 +02002132 if (ret == NULL)
2133 goto out;
2134 tmplog = ret;
2135 last_isspace = 0;
2136 break;
2137
Willy Tarreau2beef582012-12-20 17:22:52 +01002138 case LOG_FMT_BACKENDIP: // %bi
Willy Tarreau8fa99842019-07-17 11:47:11 +02002139 if (be_conn && conn_get_src(be_conn))
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002140 ret = lf_ip(tmplog, (const struct sockaddr *)be_conn->src, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002141 else
2142 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2143
William Lallemand1d705562012-03-12 12:46:41 +01002144 if (ret == NULL)
William Lallemandb7ff6a32012-03-02 14:35:21 +01002145 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002146 tmplog = ret;
William Lallemandb7ff6a32012-03-02 14:35:21 +01002147 last_isspace = 0;
2148 break;
2149
Willy Tarreau2beef582012-12-20 17:22:52 +01002150 case LOG_FMT_BACKENDPORT: // %bp
Willy Tarreau8fa99842019-07-17 11:47:11 +02002151 if (be_conn && conn_get_src(be_conn))
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002152 ret = lf_port(tmplog, (struct sockaddr *)be_conn->src, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002153 else
2154 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2155
William Lallemand5f232402012-04-05 18:02:55 +02002156 if (ret == NULL)
2157 goto out;
2158 tmplog = ret;
2159 last_isspace = 0;
2160 break;
2161
Willy Tarreau2beef582012-12-20 17:22:52 +01002162 case LOG_FMT_SERVERIP: // %si
Willy Tarreau8fa99842019-07-17 11:47:11 +02002163 if (be_conn && conn_get_dst(be_conn))
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002164 ret = lf_ip(tmplog, (struct sockaddr *)be_conn->dst, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002165 else
2166 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2167
William Lallemand5f232402012-04-05 18:02:55 +02002168 if (ret == NULL)
2169 goto out;
2170 tmplog = ret;
2171 last_isspace = 0;
2172 break;
2173
Willy Tarreau2beef582012-12-20 17:22:52 +01002174 case LOG_FMT_SERVERPORT: // %sp
Willy Tarreau8fa99842019-07-17 11:47:11 +02002175 if (be_conn && conn_get_dst(be_conn))
Willy Tarreau6c6365f2019-07-17 16:48:18 +02002176 ret = lf_port(tmplog, (struct sockaddr *)be_conn->dst, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002177 else
2178 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2179
William Lallemand1d705562012-03-12 12:46:41 +01002180 if (ret == NULL)
William Lallemandb7ff6a32012-03-02 14:35:21 +01002181 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002182 tmplog = ret;
William Lallemandb7ff6a32012-03-02 14:35:21 +01002183 last_isspace = 0;
2184 break;
2185
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002186 case LOG_FMT_DATE: // %t = accept date
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002187 get_localtime(logs->accept_date.tv_sec, &tm);
2188 ret = date2str_log(tmplog, &tm, &logs->accept_date, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002189 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002190 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002191 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002192 last_isspace = 0;
2193 break;
2194
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002195 case LOG_FMT_tr: // %tr = start of request date
2196 /* Note that the timers are valid if we get here */
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002197 tv_ms_add(&tv, &logs->accept_date, logs->t_idle >= 0 ? logs->t_idle + logs->t_handshake : 0);
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002198 get_localtime(tv.tv_sec, &tm);
2199 ret = date2str_log(tmplog, &tm, &tv, dst + maxsize - tmplog);
2200 if (ret == NULL)
2201 goto out;
2202 tmplog = ret;
2203 last_isspace = 0;
2204 break;
2205
2206 case LOG_FMT_DATEGMT: // %T = accept date, GMT
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002207 get_gmtime(logs->accept_date.tv_sec, &tm);
William Lallemand5f232402012-04-05 18:02:55 +02002208 ret = gmt2str_log(tmplog, &tm, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002209 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002210 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002211 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002212 last_isspace = 0;
2213 break;
2214
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002215 case LOG_FMT_trg: // %trg = start of request date, GMT
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002216 tv_ms_add(&tv, &logs->accept_date, logs->t_idle >= 0 ? logs->t_idle + logs->t_handshake : 0);
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002217 get_gmtime(tv.tv_sec, &tm);
2218 ret = gmt2str_log(tmplog, &tm, dst + maxsize - tmplog);
2219 if (ret == NULL)
2220 goto out;
2221 tmplog = ret;
2222 last_isspace = 0;
2223 break;
2224
2225 case LOG_FMT_DATELOCAL: // %Tl = accept date, local
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002226 get_localtime(logs->accept_date.tv_sec, &tm);
2227 ret = localdate2str_log(tmplog, logs->accept_date.tv_sec, &tm, dst + maxsize - tmplog);
Yuxans Yao4e25b012012-10-19 10:36:09 +08002228 if (ret == NULL)
2229 goto out;
2230 tmplog = ret;
2231 last_isspace = 0;
2232 break;
2233
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002234 case LOG_FMT_trl: // %trl = start of request date, local
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002235 tv_ms_add(&tv, &logs->accept_date, logs->t_idle >= 0 ? logs->t_idle + logs->t_handshake : 0);
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002236 get_localtime(tv.tv_sec, &tm);
2237 ret = localdate2str_log(tmplog, tv.tv_sec, &tm, dst + maxsize - tmplog);
2238 if (ret == NULL)
2239 goto out;
2240 tmplog = ret;
2241 last_isspace = 0;
2242 break;
2243
William Lallemand5f232402012-04-05 18:02:55 +02002244 case LOG_FMT_TS: // %Ts
William Lallemand5f232402012-04-05 18:02:55 +02002245 if (tmp->options & LOG_OPT_HEXA) {
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002246 iret = snprintf(tmplog, dst + maxsize - tmplog, "%04X", (unsigned int)logs->accept_date.tv_sec);
William Lallemand5f232402012-04-05 18:02:55 +02002247 if (iret < 0 || iret > dst + maxsize - tmplog)
2248 goto out;
2249 last_isspace = 0;
2250 tmplog += iret;
2251 } else {
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002252 ret = ltoa_o(logs->accept_date.tv_sec, tmplog, dst + maxsize - tmplog);
William Lallemand5f232402012-04-05 18:02:55 +02002253 if (ret == NULL)
2254 goto out;
2255 tmplog = ret;
2256 last_isspace = 0;
2257 }
2258 break;
2259
William Lallemand1d705562012-03-12 12:46:41 +01002260 case LOG_FMT_MS: // %ms
William Lallemand5f232402012-04-05 18:02:55 +02002261 if (tmp->options & LOG_OPT_HEXA) {
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002262 iret = snprintf(tmplog, dst + maxsize - tmplog, "%02X",(unsigned int)logs->accept_date.tv_usec/1000);
William Lallemand5f232402012-04-05 18:02:55 +02002263 if (iret < 0 || iret > dst + maxsize - tmplog)
2264 goto out;
2265 last_isspace = 0;
2266 tmplog += iret;
2267 } else {
2268 if ((dst + maxsize - tmplog) < 4)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002269 goto out;
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002270 ret = utoa_pad((unsigned int)logs->accept_date.tv_usec/1000,
Willy Tarreau9e60cd82013-01-24 01:18:16 +01002271 tmplog, 4);
2272 if (ret == NULL)
William Lallemand51b5dca2012-03-26 17:52:55 +02002273 goto out;
Willy Tarreau9e60cd82013-01-24 01:18:16 +01002274 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002275 last_isspace = 0;
William Lallemand5f232402012-04-05 18:02:55 +02002276 }
2277 break;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002278
William Lallemand1d705562012-03-12 12:46:41 +01002279 case LOG_FMT_FRONTEND: // %f
William Lallemandbddd4fd2012-02-27 11:23:10 +01002280 src = fe->id;
William Lallemand5f232402012-04-05 18:02:55 +02002281 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002282 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002283 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002284 tmplog = ret;
William Lallemand51b5dca2012-03-26 17:52:55 +02002285 last_isspace = 0;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002286 break;
2287
Willy Tarreau773d65f2012-10-12 14:56:11 +02002288 case LOG_FMT_FRONTEND_XPRT: // %ft
2289 src = fe->id;
2290 if (tmp->options & LOG_OPT_QUOTE)
2291 LOGCHAR('"');
2292 iret = strlcpy2(tmplog, src, dst + maxsize - tmplog);
2293 if (iret == 0)
2294 goto out;
2295 tmplog += iret;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01002296 if (sess->listener->bind_conf->xprt == xprt_get(XPRT_SSL))
Willy Tarreau773d65f2012-10-12 14:56:11 +02002297 LOGCHAR('~');
Willy Tarreau773d65f2012-10-12 14:56:11 +02002298 if (tmp->options & LOG_OPT_QUOTE)
2299 LOGCHAR('"');
2300 last_isspace = 0;
2301 break;
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02002302#ifdef USE_OPENSSL
2303 case LOG_FMT_SSL_CIPHER: // %sslc
2304 src = NULL;
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002305 conn = objt_conn(sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002306 if (conn) {
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02002307 src = ssl_sock_get_cipher_name(conn);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002308 }
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02002309 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
2310 if (ret == NULL)
2311 goto out;
2312 tmplog = ret;
2313 last_isspace = 0;
2314 break;
Willy Tarreau773d65f2012-10-12 14:56:11 +02002315
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02002316 case LOG_FMT_SSL_VERSION: // %sslv
2317 src = NULL;
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002318 conn = objt_conn(sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002319 if (conn) {
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02002320 src = ssl_sock_get_proto_version(conn);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002321 }
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02002322 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
2323 if (ret == NULL)
2324 goto out;
2325 tmplog = ret;
2326 last_isspace = 0;
2327 break;
2328#endif
William Lallemand1d705562012-03-12 12:46:41 +01002329 case LOG_FMT_BACKEND: // %b
William Lallemandbddd4fd2012-02-27 11:23:10 +01002330 src = be->id;
William Lallemand5f232402012-04-05 18:02:55 +02002331 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002332 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002333 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002334 tmplog = ret;
William Lallemand51b5dca2012-03-26 17:52:55 +02002335 last_isspace = 0;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002336 break;
2337
William Lallemand1d705562012-03-12 12:46:41 +01002338 case LOG_FMT_SERVER: // %s
Willy Tarreaue1809df2018-09-05 15:30:16 +02002339 switch (obj_type(s ? s->target : NULL)) {
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002340 case OBJ_TYPE_SERVER:
Willy Tarreau1aaf3242018-09-20 11:13:58 +02002341 src = __objt_server(s->target)->id;
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002342 break;
2343 case OBJ_TYPE_APPLET:
Willy Tarreau1aaf3242018-09-20 11:13:58 +02002344 src = __objt_applet(s->target)->name;
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002345 break;
2346 default:
2347 src = "<NOSRV>";
2348 break;
2349 }
William Lallemand5f232402012-04-05 18:02:55 +02002350 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002351 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002352 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002353 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002354 last_isspace = 0;
2355 break;
2356
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002357 case LOG_FMT_Th: // %Th = handshake time
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002358 ret = ltoa_o(logs->t_handshake, tmplog, dst + maxsize - tmplog);
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002359 if (ret == NULL)
2360 goto out;
2361 tmplog = ret;
2362 last_isspace = 0;
2363 break;
2364
2365 case LOG_FMT_Ti: // %Ti = HTTP idle time
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002366 ret = ltoa_o(logs->t_idle, tmplog, dst + maxsize - tmplog);
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002367 if (ret == NULL)
2368 goto out;
2369 tmplog = ret;
2370 last_isspace = 0;
2371 break;
2372
2373 case LOG_FMT_TR: // %TR = HTTP request time
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002374 ret = ltoa_o((t_request >= 0) ? t_request - logs->t_idle - logs->t_handshake : -1,
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002375 tmplog, dst + maxsize - tmplog);
2376 if (ret == NULL)
2377 goto out;
2378 tmplog = ret;
2379 last_isspace = 0;
2380 break;
2381
2382 case LOG_FMT_TQ: // %Tq = Th + Ti + TR
William Lallemand5f232402012-04-05 18:02:55 +02002383 ret = ltoa_o(t_request, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002384 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002385 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002386 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002387 last_isspace = 0;
2388 break;
2389
William Lallemand1d705562012-03-12 12:46:41 +01002390 case LOG_FMT_TW: // %Tw
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002391 ret = ltoa_o((logs->t_queue >= 0) ? logs->t_queue - t_request : -1,
William Lallemand5f232402012-04-05 18:02:55 +02002392 tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002393 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002394 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002395 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002396 last_isspace = 0;
2397 break;
2398
William Lallemand1d705562012-03-12 12:46:41 +01002399 case LOG_FMT_TC: // %Tc
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002400 ret = ltoa_o((logs->t_connect >= 0) ? logs->t_connect - logs->t_queue : -1,
William Lallemand5f232402012-04-05 18:02:55 +02002401 tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002402 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002403 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002404 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002405 last_isspace = 0;
2406 break;
2407
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002408 case LOG_FMT_Tr: // %Tr
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002409 ret = ltoa_o((logs->t_data >= 0) ? logs->t_data - logs->t_connect : -1,
William Lallemand5f232402012-04-05 18:02:55 +02002410 tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002411 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002412 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002413 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002414 last_isspace = 0;
2415 break;
2416
Willy Tarreau27b639d2016-05-17 17:55:27 +02002417 case LOG_FMT_TD: // %Td
Willy Tarreaua21c0e62018-09-05 15:07:15 +02002418 if (be->mode == PR_MODE_HTTP)
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002419 ret = ltoa_o((logs->t_data >= 0) ? logs->t_close - logs->t_data : -1,
Willy Tarreau27b639d2016-05-17 17:55:27 +02002420 tmplog, dst + maxsize - tmplog);
2421 else
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002422 ret = ltoa_o((logs->t_connect >= 0) ? logs->t_close - logs->t_connect : -1,
Willy Tarreau27b639d2016-05-17 17:55:27 +02002423 tmplog, dst + maxsize - tmplog);
2424 if (ret == NULL)
2425 goto out;
2426 tmplog = ret;
2427 last_isspace = 0;
2428 break;
2429
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002430 case LOG_FMT_Ta: // %Ta = active time = Tt - Th - Ti
2431 if (!(fe->to_log & LW_BYTES))
2432 LOGCHAR('+');
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002433 ret = ltoa_o(logs->t_close - (logs->t_idle >= 0 ? logs->t_idle + logs->t_handshake : 0),
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002434 tmplog, dst + maxsize - tmplog);
2435 if (ret == NULL)
2436 goto out;
2437 tmplog = ret;
2438 last_isspace = 0;
2439 break;
2440
2441 case LOG_FMT_TT: // %Tt = total time
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002442 if (!(fe->to_log & LW_BYTES))
William Lallemand1d705562012-03-12 12:46:41 +01002443 LOGCHAR('+');
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002444 ret = ltoa_o(logs->t_close, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002445 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002446 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002447 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002448 last_isspace = 0;
2449 break;
2450
Willy Tarreau2beef582012-12-20 17:22:52 +01002451 case LOG_FMT_STATUS: // %ST
Willy Tarreau57bc8912016-04-25 17:09:40 +02002452 ret = ltoa_o(txn ? txn->status : 0, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002453 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002454 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002455 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002456 last_isspace = 0;
2457 break;
2458
William Lallemand1d705562012-03-12 12:46:41 +01002459 case LOG_FMT_BYTES: // %B
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002460 if (!(fe->to_log & LW_BYTES))
William Lallemand1d705562012-03-12 12:46:41 +01002461 LOGCHAR('+');
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002462 ret = lltoa(logs->bytes_out, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002463 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002464 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002465 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002466 last_isspace = 0;
2467 break;
2468
Willy Tarreauc5259fd2012-12-20 15:38:04 +01002469 case LOG_FMT_BYTES_UP: // %U
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002470 ret = lltoa(logs->bytes_in, tmplog, dst + maxsize - tmplog);
Willy Tarreauc5259fd2012-12-20 15:38:04 +01002471 if (ret == NULL)
2472 goto out;
2473 tmplog = ret;
2474 last_isspace = 0;
2475 break;
2476
Willy Tarreau2beef582012-12-20 17:22:52 +01002477 case LOG_FMT_CCLIENT: // %CC
Willy Tarreau57bc8912016-04-25 17:09:40 +02002478 src = txn ? txn->cli_cookie : NULL;
William Lallemand5f232402012-04-05 18:02:55 +02002479 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002480 if (ret == NULL)
William Lallemand51b5dca2012-03-26 17:52:55 +02002481 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002482 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002483 last_isspace = 0;
2484 break;
2485
Willy Tarreau2beef582012-12-20 17:22:52 +01002486 case LOG_FMT_CSERVER: // %CS
Willy Tarreau57bc8912016-04-25 17:09:40 +02002487 src = txn ? txn->srv_cookie : NULL;
William Lallemand5f232402012-04-05 18:02:55 +02002488 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002489 if (ret == NULL)
William Lallemand51b5dca2012-03-26 17:52:55 +02002490 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002491 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002492 last_isspace = 0;
2493 break;
2494
William Lallemand1d705562012-03-12 12:46:41 +01002495 case LOG_FMT_TERMSTATE: // %ts
Willy Tarreaub8bc5252018-09-05 15:51:28 +02002496 LOGCHAR(sess_term_cond[(s_flags & SF_ERR_MASK) >> SF_ERR_SHIFT]);
2497 LOGCHAR(sess_fin_state[(s_flags & SF_FINST_MASK) >> SF_FINST_SHIFT]);
Willy Tarreau6580c062012-03-12 15:09:42 +01002498 *tmplog = '\0';
2499 last_isspace = 0;
2500 break;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002501
William Lallemand1d705562012-03-12 12:46:41 +01002502 case LOG_FMT_TERMSTATE_CK: // %tsc, same as TS with cookie state (for mode HTTP)
Willy Tarreaub8bc5252018-09-05 15:51:28 +02002503 LOGCHAR(sess_term_cond[(s_flags & SF_ERR_MASK) >> SF_ERR_SHIFT]);
2504 LOGCHAR(sess_fin_state[(s_flags & SF_FINST_MASK) >> SF_FINST_SHIFT]);
Willy Tarreau57bc8912016-04-25 17:09:40 +02002505 LOGCHAR((txn && (be->ck_opts & PR_CK_ANY)) ? sess_cookie[(txn->flags & TX_CK_MASK) >> TX_CK_SHIFT] : '-');
2506 LOGCHAR((txn && (be->ck_opts & PR_CK_ANY)) ? sess_set_cookie[(txn->flags & TX_SCK_MASK) >> TX_SCK_SHIFT] : '-');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002507 last_isspace = 0;
2508 break;
2509
William Lallemand1d705562012-03-12 12:46:41 +01002510 case LOG_FMT_ACTCONN: // %ac
William Lallemand5f232402012-04-05 18:02:55 +02002511 ret = ltoa_o(actconn, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002512 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002513 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002514 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002515 last_isspace = 0;
2516 break;
2517
William Lallemand1d705562012-03-12 12:46:41 +01002518 case LOG_FMT_FECONN: // %fc
William Lallemand5f232402012-04-05 18:02:55 +02002519 ret = ltoa_o(fe->feconn, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002520 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002521 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002522 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002523 last_isspace = 0;
2524 break;
2525
William Lallemand1d705562012-03-12 12:46:41 +01002526 case LOG_FMT_BECONN: // %bc
William Lallemand5f232402012-04-05 18:02:55 +02002527 ret = ltoa_o(be->beconn, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002528 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002529 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002530 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002531 last_isspace = 0;
2532 break;
2533
William Lallemand1d705562012-03-12 12:46:41 +01002534 case LOG_FMT_SRVCONN: // %sc
Willy Tarreaue1809df2018-09-05 15:30:16 +02002535 ret = ultoa_o(objt_server(s ? s->target : NULL) ?
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002536 objt_server(s->target)->cur_sess :
William Lallemand5f232402012-04-05 18:02:55 +02002537 0, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002538 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002539 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002540 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002541 last_isspace = 0;
2542 break;
2543
William Lallemand1d705562012-03-12 12:46:41 +01002544 case LOG_FMT_RETRIES: // %rq
Willy Tarreaub8bc5252018-09-05 15:51:28 +02002545 if (s_flags & SF_REDISP)
William Lallemand1d705562012-03-12 12:46:41 +01002546 LOGCHAR('+');
Willy Tarreauabd71a52018-09-04 19:21:44 +02002547 ret = ltoa_o((s && s->si[1].conn_retries > 0) ?
Willy Tarreau350f4872014-11-28 14:42:25 +01002548 (be->conn_retries - s->si[1].conn_retries) :
William Lallemand5f232402012-04-05 18:02:55 +02002549 be->conn_retries, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002550 if (ret == NULL)
William Lallemand51b5dca2012-03-26 17:52:55 +02002551 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002552 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002553 last_isspace = 0;
2554 break;
2555
William Lallemand1d705562012-03-12 12:46:41 +01002556 case LOG_FMT_SRVQUEUE: // %sq
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002557 ret = ltoa_o(logs->srv_queue_pos, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002558 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002559 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002560 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002561 last_isspace = 0;
2562 break;
2563
William Lallemand1d705562012-03-12 12:46:41 +01002564 case LOG_FMT_BCKQUEUE: // %bq
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002565 ret = ltoa_o(logs->prx_queue_pos, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002566 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002567 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002568 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002569 last_isspace = 0;
2570 break;
2571
William Lallemand1d705562012-03-12 12:46:41 +01002572 case LOG_FMT_HDRREQUEST: // %hr
William Lallemandbddd4fd2012-02-27 11:23:10 +01002573 /* request header */
Willy Tarreaud4f91662018-09-05 15:28:07 +02002574 if (fe->nb_req_cap && s && s->req_cap) {
William Lallemandbddd4fd2012-02-27 11:23:10 +01002575 if (tmp->options & LOG_OPT_QUOTE)
2576 LOGCHAR('"');
2577 LOGCHAR('{');
2578 for (hdr = 0; hdr < fe->nb_req_cap; hdr++) {
2579 if (hdr)
2580 LOGCHAR('|');
Willy Tarreaucb7dd012015-04-03 22:16:32 +02002581 if (s->req_cap[hdr] != NULL) {
Dragan Dosen835b9212016-02-12 13:23:03 +01002582 ret = lf_encode_string(tmplog, dst + maxsize,
2583 '#', hdr_encode_map, s->req_cap[hdr], tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002584 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002585 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002586 tmplog = ret;
William Lallemand51b5dca2012-03-26 17:52:55 +02002587 }
William Lallemandbddd4fd2012-02-27 11:23:10 +01002588 }
2589 LOGCHAR('}');
William Lallemand51b5dca2012-03-26 17:52:55 +02002590 if (tmp->options & LOG_OPT_QUOTE)
2591 LOGCHAR('"');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002592 last_isspace = 0;
2593 }
William Lallemandbddd4fd2012-02-27 11:23:10 +01002594 break;
2595
William Lallemand1d705562012-03-12 12:46:41 +01002596 case LOG_FMT_HDRREQUESTLIST: // %hrl
William Lallemandbddd4fd2012-02-27 11:23:10 +01002597 /* request header list */
Willy Tarreaud4f91662018-09-05 15:28:07 +02002598 if (fe->nb_req_cap && s && s->req_cap) {
William Lallemandbddd4fd2012-02-27 11:23:10 +01002599 for (hdr = 0; hdr < fe->nb_req_cap; hdr++) {
2600 if (hdr > 0)
2601 LOGCHAR(' ');
2602 if (tmp->options & LOG_OPT_QUOTE)
2603 LOGCHAR('"');
Willy Tarreaucb7dd012015-04-03 22:16:32 +02002604 if (s->req_cap[hdr] != NULL) {
Dragan Dosen835b9212016-02-12 13:23:03 +01002605 ret = lf_encode_string(tmplog, dst + maxsize,
2606 '#', hdr_encode_map, s->req_cap[hdr], tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002607 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002608 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002609 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002610 } else if (!(tmp->options & LOG_OPT_QUOTE))
2611 LOGCHAR('-');
2612 if (tmp->options & LOG_OPT_QUOTE)
2613 LOGCHAR('"');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002614 last_isspace = 0;
2615 }
2616 }
2617 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002618
William Lallemand1d705562012-03-12 12:46:41 +01002619
2620 case LOG_FMT_HDRRESPONS: // %hs
William Lallemandbddd4fd2012-02-27 11:23:10 +01002621 /* response header */
Willy Tarreaud4f91662018-09-05 15:28:07 +02002622 if (fe->nb_rsp_cap && s && s->res_cap) {
William Lallemandbddd4fd2012-02-27 11:23:10 +01002623 if (tmp->options & LOG_OPT_QUOTE)
2624 LOGCHAR('"');
2625 LOGCHAR('{');
2626 for (hdr = 0; hdr < fe->nb_rsp_cap; hdr++) {
2627 if (hdr)
2628 LOGCHAR('|');
Willy Tarreaucb7dd012015-04-03 22:16:32 +02002629 if (s->res_cap[hdr] != NULL) {
Dragan Dosen835b9212016-02-12 13:23:03 +01002630 ret = lf_encode_string(tmplog, dst + maxsize,
2631 '#', hdr_encode_map, s->res_cap[hdr], tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002632 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002633 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002634 tmplog = ret;
William Lallemand51b5dca2012-03-26 17:52:55 +02002635 }
William Lallemandbddd4fd2012-02-27 11:23:10 +01002636 }
2637 LOGCHAR('}');
2638 last_isspace = 0;
2639 if (tmp->options & LOG_OPT_QUOTE)
2640 LOGCHAR('"');
2641 }
William Lallemandbddd4fd2012-02-27 11:23:10 +01002642 break;
2643
William Lallemand1d705562012-03-12 12:46:41 +01002644 case LOG_FMT_HDRRESPONSLIST: // %hsl
William Lallemandbddd4fd2012-02-27 11:23:10 +01002645 /* response header list */
Willy Tarreaud4f91662018-09-05 15:28:07 +02002646 if (fe->nb_rsp_cap && s && s->res_cap) {
William Lallemandbddd4fd2012-02-27 11:23:10 +01002647 for (hdr = 0; hdr < fe->nb_rsp_cap; hdr++) {
2648 if (hdr > 0)
2649 LOGCHAR(' ');
2650 if (tmp->options & LOG_OPT_QUOTE)
2651 LOGCHAR('"');
Willy Tarreaucb7dd012015-04-03 22:16:32 +02002652 if (s->res_cap[hdr] != NULL) {
Dragan Dosen835b9212016-02-12 13:23:03 +01002653 ret = lf_encode_string(tmplog, dst + maxsize,
2654 '#', hdr_encode_map, s->res_cap[hdr], tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002655 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002656 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002657 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002658 } else if (!(tmp->options & LOG_OPT_QUOTE))
2659 LOGCHAR('-');
2660 if (tmp->options & LOG_OPT_QUOTE)
2661 LOGCHAR('"');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002662 last_isspace = 0;
2663 }
2664 }
2665 break;
2666
William Lallemand1d705562012-03-12 12:46:41 +01002667 case LOG_FMT_REQ: // %r
William Lallemandbddd4fd2012-02-27 11:23:10 +01002668 /* Request */
2669 if (tmp->options & LOG_OPT_QUOTE)
2670 LOGCHAR('"');
Willy Tarreau57bc8912016-04-25 17:09:40 +02002671 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Dragan Dosen835b9212016-02-12 13:23:03 +01002672 ret = lf_encode_string(tmplog, dst + maxsize,
2673 '#', url_encode_map, uri, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002674 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002675 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002676 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002677 if (tmp->options & LOG_OPT_QUOTE)
2678 LOGCHAR('"');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002679 last_isspace = 0;
2680 break;
William Lallemand5f232402012-04-05 18:02:55 +02002681
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002682 case LOG_FMT_HTTP_PATH: // %HP
Willy Tarreau57bc8912016-04-25 17:09:40 +02002683 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002684
Willy Tarreaub7636d12015-06-17 19:58:02 +02002685 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002686 LOGCHAR('"');
2687
2688 end = uri + strlen(uri);
2689 // look for the first whitespace character
2690 while (uri < end && !HTTP_IS_SPHT(*uri))
2691 uri++;
2692
2693 // keep advancing past multiple spaces
2694 while (uri < end && HTTP_IS_SPHT(*uri)) {
2695 uri++; nspaces++;
2696 }
2697
2698 // look for first space or question mark after url
2699 spc = uri;
2700 while (spc < end && *spc != '?' && !HTTP_IS_SPHT(*spc))
2701 spc++;
2702
Nenad Merdanovic54e439f2016-04-26 01:39:02 +02002703 if (!txn || !txn->uri || nspaces == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002704 chunk.area = "<BADREQ>";
2705 chunk.data = strlen("<BADREQ>");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002706 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002707 chunk.area = uri;
2708 chunk.data = spc - uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002709 }
2710
Dragan Dosen835b9212016-02-12 13:23:03 +01002711 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002712 if (ret == NULL || *ret != '\0')
2713 goto out;
2714
2715 tmplog = ret;
Willy Tarreaub7636d12015-06-17 19:58:02 +02002716 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002717 LOGCHAR('"');
2718
2719 last_isspace = 0;
2720 break;
2721
Andrew Hayworthe63ac872015-07-31 16:14:16 +00002722 case LOG_FMT_HTTP_QUERY: // %HQ
2723 if (tmp->options & LOG_OPT_QUOTE)
2724 LOGCHAR('"');
2725
Willy Tarreau57bc8912016-04-25 17:09:40 +02002726 if (!txn || !txn->uri) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002727 chunk.area = "<BADREQ>";
2728 chunk.data = strlen("<BADREQ>");
Andrew Hayworthe63ac872015-07-31 16:14:16 +00002729 } else {
2730 uri = txn->uri;
2731 end = uri + strlen(uri);
2732 // look for the first question mark
2733 while (uri < end && *uri != '?')
2734 uri++;
2735
2736 qmark = uri;
2737 // look for first space or question mark after url
2738 while (uri < end && !HTTP_IS_SPHT(*uri))
2739 uri++;
2740
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002741 chunk.area = qmark;
2742 chunk.data = uri - qmark;
Andrew Hayworthe63ac872015-07-31 16:14:16 +00002743 }
2744
Dragan Dosen835b9212016-02-12 13:23:03 +01002745 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworthe63ac872015-07-31 16:14:16 +00002746 if (ret == NULL || *ret != '\0')
2747 goto out;
2748
2749 tmplog = ret;
2750 if (tmp->options & LOG_OPT_QUOTE)
2751 LOGCHAR('"');
2752
2753 last_isspace = 0;
2754 break;
2755
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002756 case LOG_FMT_HTTP_URI: // %HU
Willy Tarreau57bc8912016-04-25 17:09:40 +02002757 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002758
Willy Tarreaub7636d12015-06-17 19:58:02 +02002759 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002760 LOGCHAR('"');
2761
2762 end = uri + strlen(uri);
2763 // look for the first whitespace character
2764 while (uri < end && !HTTP_IS_SPHT(*uri))
2765 uri++;
2766
2767 // keep advancing past multiple spaces
2768 while (uri < end && HTTP_IS_SPHT(*uri)) {
2769 uri++; nspaces++;
2770 }
2771
2772 // look for first space after url
2773 spc = uri;
2774 while (spc < end && !HTTP_IS_SPHT(*spc))
2775 spc++;
2776
Willy Tarreau57bc8912016-04-25 17:09:40 +02002777 if (!txn || !txn->uri || nspaces == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002778 chunk.area = "<BADREQ>";
2779 chunk.data = strlen("<BADREQ>");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002780 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002781 chunk.area = uri;
2782 chunk.data = spc - uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002783 }
2784
Dragan Dosen835b9212016-02-12 13:23:03 +01002785 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002786 if (ret == NULL || *ret != '\0')
2787 goto out;
2788
2789 tmplog = ret;
Willy Tarreaub7636d12015-06-17 19:58:02 +02002790 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002791 LOGCHAR('"');
2792
2793 last_isspace = 0;
2794 break;
2795
2796 case LOG_FMT_HTTP_METHOD: // %HM
Willy Tarreau57bc8912016-04-25 17:09:40 +02002797 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Willy Tarreaub7636d12015-06-17 19:58:02 +02002798 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002799 LOGCHAR('"');
2800
2801 end = uri + strlen(uri);
2802 // look for the first whitespace character
2803 spc = uri;
2804 while (spc < end && !HTTP_IS_SPHT(*spc))
2805 spc++;
2806
2807 if (spc == end) { // odd case, we have txn->uri, but we only got a verb
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002808 chunk.area = "<BADREQ>";
2809 chunk.data = strlen("<BADREQ>");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002810 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002811 chunk.area = uri;
2812 chunk.data = spc - uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002813 }
2814
Dragan Dosen835b9212016-02-12 13:23:03 +01002815 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002816 if (ret == NULL || *ret != '\0')
2817 goto out;
2818
2819 tmplog = ret;
Willy Tarreaub7636d12015-06-17 19:58:02 +02002820 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002821 LOGCHAR('"');
2822
2823 last_isspace = 0;
2824 break;
2825
2826 case LOG_FMT_HTTP_VERSION: // %HV
Willy Tarreau57bc8912016-04-25 17:09:40 +02002827 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Willy Tarreaub7636d12015-06-17 19:58:02 +02002828 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002829 LOGCHAR('"');
2830
2831 end = uri + strlen(uri);
2832 // look for the first whitespace character
2833 while (uri < end && !HTTP_IS_SPHT(*uri))
2834 uri++;
2835
2836 // keep advancing past multiple spaces
2837 while (uri < end && HTTP_IS_SPHT(*uri)) {
2838 uri++; nspaces++;
2839 }
2840
2841 // look for the next whitespace character
2842 while (uri < end && !HTTP_IS_SPHT(*uri))
2843 uri++;
2844
2845 // keep advancing past multiple spaces
2846 while (uri < end && HTTP_IS_SPHT(*uri))
2847 uri++;
2848
Willy Tarreau57bc8912016-04-25 17:09:40 +02002849 if (!txn || !txn->uri || nspaces == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002850 chunk.area = "<BADREQ>";
2851 chunk.data = strlen("<BADREQ>");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002852 } else if (uri == end) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002853 chunk.area = "HTTP/0.9";
2854 chunk.data = strlen("HTTP/0.9");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002855 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002856 chunk.area = uri;
2857 chunk.data = end - uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002858 }
2859
Dragan Dosen835b9212016-02-12 13:23:03 +01002860 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002861 if (ret == NULL || *ret != '\0')
2862 goto out;
2863
2864 tmplog = ret;
Willy Tarreaub7636d12015-06-17 19:58:02 +02002865 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002866 LOGCHAR('"');
2867
2868 last_isspace = 0;
2869 break;
2870
William Lallemand5f232402012-04-05 18:02:55 +02002871 case LOG_FMT_COUNTER: // %rt
2872 if (tmp->options & LOG_OPT_HEXA) {
Willy Tarreau5cacab62018-09-05 15:52:59 +02002873 iret = snprintf(tmplog, dst + maxsize - tmplog, "%04X", uniq_id);
William Lallemand5f232402012-04-05 18:02:55 +02002874 if (iret < 0 || iret > dst + maxsize - tmplog)
2875 goto out;
2876 last_isspace = 0;
2877 tmplog += iret;
2878 } else {
Willy Tarreau5cacab62018-09-05 15:52:59 +02002879 ret = ltoa_o(uniq_id, tmplog, dst + maxsize - tmplog);
William Lallemand5f232402012-04-05 18:02:55 +02002880 if (ret == NULL)
2881 goto out;
2882 tmplog = ret;
2883 last_isspace = 0;
2884 }
2885 break;
2886
Willy Tarreau7346acb2014-08-28 15:03:15 +02002887 case LOG_FMT_LOGCNT: // %lc
2888 if (tmp->options & LOG_OPT_HEXA) {
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002889 iret = snprintf(tmplog, dst + maxsize - tmplog, "%04X", fe->log_count);
Willy Tarreau7346acb2014-08-28 15:03:15 +02002890 if (iret < 0 || iret > dst + maxsize - tmplog)
2891 goto out;
2892 last_isspace = 0;
2893 tmplog += iret;
2894 } else {
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002895 ret = ultoa_o(fe->log_count, tmplog, dst + maxsize - tmplog);
Willy Tarreau7346acb2014-08-28 15:03:15 +02002896 if (ret == NULL)
2897 goto out;
2898 tmplog = ret;
2899 last_isspace = 0;
2900 }
2901 break;
2902
William Lallemand5f232402012-04-05 18:02:55 +02002903 case LOG_FMT_HOSTNAME: // %H
2904 src = hostname;
2905 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
2906 if (ret == NULL)
2907 goto out;
2908 tmplog = ret;
2909 last_isspace = 0;
2910 break;
2911
2912 case LOG_FMT_PID: // %pid
2913 if (tmp->options & LOG_OPT_HEXA) {
2914 iret = snprintf(tmplog, dst + maxsize - tmplog, "%04X", pid);
2915 if (iret < 0 || iret > dst + maxsize - tmplog)
2916 goto out;
2917 last_isspace = 0;
2918 tmplog += iret;
2919 } else {
2920 ret = ltoa_o(pid, tmplog, dst + maxsize - tmplog);
2921 if (ret == NULL)
2922 goto out;
2923 tmplog = ret;
2924 last_isspace = 0;
2925 }
2926 break;
William Lallemanda73203e2012-03-12 12:48:57 +01002927
2928 case LOG_FMT_UNIQUEID: // %ID
William Lallemand5b7ea3a2013-08-28 15:44:19 +02002929 ret = NULL;
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002930 if (s)
2931 ret = lf_text_len(tmplog, s->unique_id.ptr, s->unique_id.len, maxsize - (tmplog - dst), tmp);
2932 else
2933 ret = lf_text_len(tmplog, NULL, 0, maxsize - (tmplog - dst), tmp);
William Lallemanda73203e2012-03-12 12:48:57 +01002934 if (ret == NULL)
2935 goto out;
2936 tmplog = ret;
2937 last_isspace = 0;
2938 break;
2939
William Lallemandbddd4fd2012-02-27 11:23:10 +01002940 }
2941 }
2942
2943out:
William Lallemand1d705562012-03-12 12:46:41 +01002944 /* *tmplog is a unused character */
2945 *tmplog = '\0';
Willy Tarreaudf974472012-12-28 02:44:01 +01002946 return tmplog - dst;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002947
Willy Tarreaubaaee002006-06-26 02:48:02 +02002948}
2949
William Lallemand1d705562012-03-12 12:46:41 +01002950/*
Willy Tarreau87b09662015-04-03 00:22:06 +02002951 * send a log for the stream when we have enough info about it.
William Lallemand1d705562012-03-12 12:46:41 +01002952 * Will not log if the frontend has no log defined.
2953 */
Willy Tarreau87b09662015-04-03 00:22:06 +02002954void strm_log(struct stream *s)
William Lallemand1d705562012-03-12 12:46:41 +01002955{
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002956 struct session *sess = s->sess;
William Lallemand1d705562012-03-12 12:46:41 +01002957 int size, err, level;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002958 int sd_size = 0;
William Lallemand1d705562012-03-12 12:46:41 +01002959
2960 /* if we don't want to log normal traffic, return now */
Willy Tarreaue7dff022015-04-03 01:14:29 +02002961 err = (s->flags & SF_REDISP) ||
2962 ((s->flags & SF_ERR_MASK) > SF_ERR_LOCAL) ||
2963 (((s->flags & SF_ERR_MASK) == SF_ERR_NONE) &&
Willy Tarreau350f4872014-11-28 14:42:25 +01002964 (s->si[1].conn_retries != s->be->conn_retries)) ||
Willy Tarreaueee5b512015-04-03 23:46:31 +02002965 ((sess->fe->mode == PR_MODE_HTTP) && s->txn && s->txn->status >= 500);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002966
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002967 if (!err && (sess->fe->options2 & PR_O2_NOLOGNORM))
William Lallemand1d705562012-03-12 12:46:41 +01002968 return;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002969
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002970 if (LIST_ISEMPTY(&sess->fe->logsrvs))
William Lallemand1d705562012-03-12 12:46:41 +01002971 return;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002972
Willy Tarreauabcd5142013-06-11 17:18:02 +02002973 if (s->logs.level) { /* loglevel was overridden */
2974 if (s->logs.level == -1) {
2975 s->logs.logwait = 0; /* logs disabled */
2976 return;
2977 }
2978 level = s->logs.level - 1;
2979 }
2980 else {
2981 level = LOG_INFO;
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002982 if (err && (sess->fe->options2 & PR_O2_LOGERRORS))
Willy Tarreauabcd5142013-06-11 17:18:02 +02002983 level = LOG_ERR;
2984 }
William Lallemand1d705562012-03-12 12:46:41 +01002985
William Lallemand5b7ea3a2013-08-28 15:44:19 +02002986 /* if unique-id was not generated */
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002987 if (!isttest(s->unique_id) && !LIST_ISEMPTY(&sess->fe->format_unique_id)) {
Tim Duesterhus2825b4b2020-02-28 15:13:34 +01002988 stream_generate_unique_id(s, &sess->fe->format_unique_id);
William Lallemand5b7ea3a2013-08-28 15:44:19 +02002989 }
2990
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002991 if (!LIST_ISEMPTY(&sess->fe->logformat_sd)) {
2992 sd_size = build_logline(s, logline_rfc5424, global.max_syslog_len,
2993 &sess->fe->logformat_sd);
2994 }
2995
Dragan Dosen59cee972015-09-19 22:09:02 +02002996 size = build_logline(s, logline, global.max_syslog_len, &sess->fe->logformat);
William Lallemand1d705562012-03-12 12:46:41 +01002997 if (size > 0) {
Olivier Houchardd2ee3e72019-03-08 18:53:21 +01002998 _HA_ATOMIC_ADD(&sess->fe->log_count, 1);
Christopher Faulet5c6fefc2019-08-11 19:40:12 +02002999 __send_log(&sess->fe->logsrvs, &sess->fe->log_tag, level,
3000 logline, size + 1, logline_rfc5424, sd_size);
William Lallemand1d705562012-03-12 12:46:41 +01003001 s->logs.logwait = 0;
3002 }
3003}
William Lallemandbddd4fd2012-02-27 11:23:10 +01003004
Willy Tarreau53839352018-09-05 19:51:10 +02003005/*
3006 * send a minimalist log for the session. Will not log if the frontend has no
3007 * log defined. It is assumed that this is only used to report anomalies that
3008 * cannot lead to the creation of a regular stream. Because of this the log
3009 * level is LOG_INFO or LOG_ERR depending on the "log-separate-error" setting
3010 * in the frontend. The caller must simply know that it should not call this
Willy Tarreau9fa267d2018-10-05 10:22:27 +02003011 * function to report unimportant events. It is safe to call this function with
3012 * sess==NULL (will not do anything).
Willy Tarreau53839352018-09-05 19:51:10 +02003013 */
3014void sess_log(struct session *sess)
3015{
3016 int size, level;
3017 int sd_size = 0;
3018
Willy Tarreau9fa267d2018-10-05 10:22:27 +02003019 if (!sess)
3020 return;
3021
Willy Tarreau53839352018-09-05 19:51:10 +02003022 if (LIST_ISEMPTY(&sess->fe->logsrvs))
3023 return;
3024
3025 level = LOG_INFO;
3026 if (sess->fe->options2 & PR_O2_LOGERRORS)
3027 level = LOG_ERR;
3028
3029 if (!LIST_ISEMPTY(&sess->fe->logformat_sd)) {
3030 sd_size = sess_build_logline(sess, NULL,
3031 logline_rfc5424, global.max_syslog_len,
3032 &sess->fe->logformat_sd);
3033 }
3034
3035 size = sess_build_logline(sess, NULL, logline, global.max_syslog_len, &sess->fe->logformat);
3036 if (size > 0) {
Olivier Houchardd2ee3e72019-03-08 18:53:21 +01003037 _HA_ATOMIC_ADD(&sess->fe->log_count, 1);
Christopher Faulet5c6fefc2019-08-11 19:40:12 +02003038 __send_log(&sess->fe->logsrvs, &sess->fe->log_tag, level,
3039 logline, size + 1, logline_rfc5424, sd_size);
Willy Tarreau53839352018-09-05 19:51:10 +02003040 }
3041}
3042
Christopher Faulet5c6fefc2019-08-11 19:40:12 +02003043void app_log(struct list *logsrvs, struct buffer *tag, int level, const char *format, ...)
3044{
3045 va_list argp;
3046 int data_len;
3047
3048 if (level < 0 || format == NULL || logline == NULL)
3049 return;
3050
3051 va_start(argp, format);
3052 data_len = vsnprintf(logline, global.max_syslog_len, format, argp);
3053 if (data_len < 0 || data_len > global.max_syslog_len)
3054 data_len = global.max_syslog_len;
3055 va_end(argp);
3056
3057 __send_log(logsrvs, tag, level, logline, data_len, default_rfc5424_sd_log_format, 2);
3058}
3059
Willy Tarreau869efd52019-11-15 15:16:57 +01003060/* parse the "show startup-logs" command, returns 1 if a message is returned, otherwise zero */
3061static int cli_parse_show_startup_logs(char **args, char *payload, struct appctx *appctx, void *private)
Christopher Fauletc1b730a2017-10-24 12:00:51 +02003062{
Willy Tarreau869efd52019-11-15 15:16:57 +01003063 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
3064 return 1;
Christopher Fauletc1b730a2017-10-24 12:00:51 +02003065
Willy Tarreau869efd52019-11-15 15:16:57 +01003066 if (!startup_logs)
3067 return cli_msg(appctx, LOG_INFO, "\n"); // nothing to print
3068
3069 return ring_attach_cli(startup_logs, appctx);
Christopher Fauletc1b730a2017-10-24 12:00:51 +02003070}
3071
3072/* register cli keywords */
3073static struct cli_kw_list cli_kws = {{ },{
3074 { { "show", "startup-logs", NULL },
Willy Tarreau869efd52019-11-15 15:16:57 +01003075 "show startup-logs : report logs emitted during HAProxy startup", cli_parse_show_startup_logs, NULL, NULL },
Christopher Fauletc1b730a2017-10-24 12:00:51 +02003076 {{},}
3077}};
3078
Willy Tarreau0108d902018-11-25 19:14:37 +01003079INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3080
Willy Tarreau082b6282019-05-22 14:42:12 +02003081REGISTER_PER_THREAD_ALLOC(init_log_buffers);
3082REGISTER_PER_THREAD_FREE(deinit_log_buffers);
Willy Tarreau172f5ce2018-11-26 11:21:50 +01003083
Willy Tarreaubaaee002006-06-26 02:48:02 +02003084/*
3085 * Local variables:
3086 * c-indent-level: 8
3087 * c-basic-offset: 8
3088 * End:
3089 */