blob: 7e14d89e2cb846c7443b960c7bbc3f6496b8fbe2 [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>
William Lallemand5f232402012-04-05 18:02:55 +020039#include <proto/frontend.h>
Willy Tarreauec6c5df2008-07-15 00:22:45 +020040#include <proto/log.h>
Willy Tarreauc8368452012-12-21 00:09:23 +010041#include <proto/sample.h>
Willy Tarreauc125cef2019-05-10 09:58:43 +020042#include <proto/ssl_sock.h>
Willy Tarreaufb0afa72015-04-03 14:46:27 +020043#include <proto/stream.h>
Willy Tarreau827aee92011-03-10 16:55:02 +010044#include <proto/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020045
Dragan Dosen43885c72015-10-01 13:18:13 +020046struct log_fmt {
47 char *name;
48 struct {
Willy Tarreau83061a82018-07-13 11:56:34 +020049 struct buffer sep1; /* first pid separator */
50 struct buffer sep2; /* second pid separator */
Dragan Dosen43885c72015-10-01 13:18:13 +020051 } pid;
52};
53
54static const struct log_fmt log_formats[LOG_FORMATS] = {
55 [LOG_FORMAT_RFC3164] = {
56 .name = "rfc3164",
57 .pid = {
Willy Tarreau843b7cb2018-07-13 10:54:26 +020058 .sep1 = { .area = "[", .data = 1 },
59 .sep2 = { .area = "]: ", .data = 3 }
Dragan Dosen43885c72015-10-01 13:18:13 +020060 }
61 },
62 [LOG_FORMAT_RFC5424] = {
63 .name = "rfc5424",
64 .pid = {
Willy Tarreau843b7cb2018-07-13 10:54:26 +020065 .sep1 = { .area = " ", .data = 1 },
66 .sep2 = { .area = " - ", .data = 3 }
Dragan Dosen43885c72015-10-01 13:18:13 +020067 }
Willy Tarreaue8746a02018-11-12 08:45:00 +010068 },
69 [LOG_FORMAT_SHORT] = {
70 .name = "short",
71 .pid = {
72 .sep1 = { .area = "", .data = 0 },
73 .sep2 = { .area = " ", .data = 1 },
74 }
75 },
Willy Tarreauc1b06452018-11-12 11:57:56 +010076 [LOG_FORMAT_RAW] = {
77 .name = "raw",
78 .pid = {
79 .sep1 = { .area = "", .data = 0 },
80 .sep2 = { .area = "", .data = 0 },
81 }
82 },
Dragan Dosen1322d092015-09-22 16:05:32 +020083};
84
Dragan Dosen835b9212016-02-12 13:23:03 +010085#define FD_SETS_ARE_BITFIELDS
86#ifdef FD_SETS_ARE_BITFIELDS
87/*
88 * This map is used with all the FD_* macros to check whether a particular bit
89 * is set or not. Each bit represents an ACSII code. FD_SET() sets those bytes
90 * which should be escaped. When FD_ISSET() returns non-zero, it means that the
91 * byte should be escaped. Be careful to always pass bytes from 0 to 255
92 * exclusively to the macros.
93 */
94fd_set rfc5424_escape_map[(sizeof(fd_set) > (256/8)) ? 1 : ((256/8) / sizeof(fd_set))];
Willy Tarreaue10cd482018-09-10 18:16:53 +020095fd_set hdr_encode_map[(sizeof(fd_set) > (256/8)) ? 1 : ((256/8) / sizeof(fd_set))];
96fd_set url_encode_map[(sizeof(fd_set) > (256/8)) ? 1 : ((256/8) / sizeof(fd_set))];
97fd_set http_encode_map[(sizeof(fd_set) > (256/8)) ? 1 : ((256/8) / sizeof(fd_set))];
Dragan Dosen835b9212016-02-12 13:23:03 +010098
99#else
100#error "Check if your OS uses bitfields for fd_sets"
101#endif
102
Willy Tarreaubaaee002006-06-26 02:48:02 +0200103const char *log_facilities[NB_LOG_FACILITIES] = {
104 "kern", "user", "mail", "daemon",
105 "auth", "syslog", "lpr", "news",
106 "uucp", "cron", "auth2", "ftp",
107 "ntp", "audit", "alert", "cron2",
108 "local0", "local1", "local2", "local3",
109 "local4", "local5", "local6", "local7"
110};
111
Willy Tarreaubaaee002006-06-26 02:48:02 +0200112const char *log_levels[NB_LOG_LEVELS] = {
113 "emerg", "alert", "crit", "err",
114 "warning", "notice", "info", "debug"
115};
116
Willy Tarreau570f2212013-06-10 16:42:09 +0200117const 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 +0200118const char sess_fin_state[8] = "-RCHDLQT"; /* cliRequest, srvConnect, srvHeader, Data, Last, Queue, Tarpit */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200119
William Lallemand723b73a2012-02-08 16:37:49 +0100120
121/* log_format */
122struct logformat_type {
123 char *name;
124 int type;
William Lallemandbddd4fd2012-02-27 11:23:10 +0100125 int mode;
William Lallemand5e19a282012-04-02 16:22:10 +0200126 int lw; /* logwait bitsfield */
William Lallemandb7ff6a32012-03-02 14:35:21 +0100127 int (*config_callback)(struct logformat_node *node, struct proxy *curproxy);
Willy Tarreau2beef582012-12-20 17:22:52 +0100128 const char *replace_by; /* new option to use instead of old one */
William Lallemand723b73a2012-02-08 16:37:49 +0100129};
130
William Lallemandb7ff6a32012-03-02 14:35:21 +0100131int prepare_addrsource(struct logformat_node *node, struct proxy *curproxy);
132
William Lallemand723b73a2012-02-08 16:37:49 +0100133/* log_format variable names */
134static const struct logformat_type logformat_keywords[] = {
William Lallemand5e19a282012-04-02 16:22:10 +0200135 { "o", LOG_FMT_GLOBAL, PR_MODE_TCP, 0, NULL }, /* global option */
Willy Tarreau2beef582012-12-20 17:22:52 +0100136
137 /* please keep these lines sorted ! */
138 { "B", LOG_FMT_BYTES, PR_MODE_TCP, LW_BYTES, NULL }, /* bytes from server to client */
139 { "CC", LOG_FMT_CCLIENT, PR_MODE_HTTP, LW_REQHDR, NULL }, /* client cookie */
140 { "CS", LOG_FMT_CSERVER, PR_MODE_HTTP, LW_RSPHDR, NULL }, /* server cookie */
141 { "H", LOG_FMT_HOSTNAME, PR_MODE_TCP, LW_INIT, NULL }, /* Hostname */
142 { "ID", LOG_FMT_UNIQUEID, PR_MODE_HTTP, LW_BYTES, NULL }, /* Unique ID */
Willy Tarreau4bf99632014-06-13 12:21:40 +0200143 { "ST", LOG_FMT_STATUS, PR_MODE_TCP, LW_RESP, NULL }, /* status code */
William Lallemand5e19a282012-04-02 16:22:10 +0200144 { "T", LOG_FMT_DATEGMT, PR_MODE_TCP, LW_INIT, NULL }, /* date GMT */
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +0200145 { "Ta", LOG_FMT_Ta, PR_MODE_HTTP, LW_BYTES, NULL }, /* Time active (tr to end) */
Willy Tarreau2beef582012-12-20 17:22:52 +0100146 { "Tc", LOG_FMT_TC, PR_MODE_TCP, LW_BYTES, NULL }, /* Tc */
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +0200147 { "Th", LOG_FMT_Th, PR_MODE_TCP, LW_BYTES, NULL }, /* Time handshake */
148 { "Ti", LOG_FMT_Ti, PR_MODE_HTTP, LW_BYTES, NULL }, /* Time idle */
149 { "Tl", LOG_FMT_DATELOCAL, PR_MODE_TCP, LW_INIT, NULL }, /* date local timezone */
150 { "Tq", LOG_FMT_TQ, PR_MODE_HTTP, LW_BYTES, NULL }, /* Tq=Th+Ti+TR */
151 { "Tr", LOG_FMT_Tr, PR_MODE_HTTP, LW_BYTES, NULL }, /* Tr */
152 { "TR", LOG_FMT_TR, PR_MODE_HTTP, LW_BYTES, NULL }, /* Time to receive a valid request */
Willy Tarreau27b639d2016-05-17 17:55:27 +0200153 { "Td", LOG_FMT_TD, PR_MODE_TCP, LW_BYTES, NULL }, /* Td = Tt - (Tq + Tw + Tc + Tr) */
Willy Tarreau2beef582012-12-20 17:22:52 +0100154 { "Ts", LOG_FMT_TS, PR_MODE_TCP, LW_INIT, NULL }, /* timestamp GMT */
William Lallemand5e19a282012-04-02 16:22:10 +0200155 { "Tt", LOG_FMT_TT, PR_MODE_TCP, LW_BYTES, NULL }, /* Tt */
Willy Tarreau2beef582012-12-20 17:22:52 +0100156 { "Tw", LOG_FMT_TW, PR_MODE_TCP, LW_BYTES, NULL }, /* Tw */
157 { "U", LOG_FMT_BYTES_UP, PR_MODE_TCP, LW_BYTES, NULL }, /* bytes from client to server */
William Lallemand5e19a282012-04-02 16:22:10 +0200158 { "ac", LOG_FMT_ACTCONN, PR_MODE_TCP, LW_BYTES, NULL }, /* actconn */
Willy Tarreau2beef582012-12-20 17:22:52 +0100159 { "b", LOG_FMT_BACKEND, PR_MODE_TCP, LW_INIT, NULL }, /* backend */
William Lallemand5e19a282012-04-02 16:22:10 +0200160 { "bc", LOG_FMT_BECONN, PR_MODE_TCP, LW_BYTES, NULL }, /* beconn */
Willy Tarreau2beef582012-12-20 17:22:52 +0100161 { "bi", LOG_FMT_BACKENDIP, PR_MODE_TCP, LW_BCKIP, prepare_addrsource }, /* backend source ip */
162 { "bp", LOG_FMT_BACKENDPORT, PR_MODE_TCP, LW_BCKIP, prepare_addrsource }, /* backend source port */
William Lallemand5e19a282012-04-02 16:22:10 +0200163 { "bq", LOG_FMT_BCKQUEUE, PR_MODE_TCP, LW_BYTES, NULL }, /* backend_queue */
Willy Tarreaud02286d2017-06-23 11:23:43 +0200164 { "ci", LOG_FMT_CLIENTIP, PR_MODE_TCP, LW_CLIP | LW_XPRT, NULL }, /* client ip */
165 { "cp", LOG_FMT_CLIENTPORT, PR_MODE_TCP, LW_CLIP | LW_XPRT, NULL }, /* client port */
Willy Tarreau2beef582012-12-20 17:22:52 +0100166 { "f", LOG_FMT_FRONTEND, PR_MODE_TCP, LW_INIT, NULL }, /* frontend */
167 { "fc", LOG_FMT_FECONN, PR_MODE_TCP, LW_BYTES, NULL }, /* feconn */
Willy Tarreaud02286d2017-06-23 11:23:43 +0200168 { "fi", LOG_FMT_FRONTENDIP, PR_MODE_TCP, LW_FRTIP | LW_XPRT, NULL }, /* frontend ip */
169 { "fp", LOG_FMT_FRONTENDPORT, PR_MODE_TCP, LW_FRTIP | LW_XPRT, NULL }, /* frontend port */
Willy Tarreau2beef582012-12-20 17:22:52 +0100170 { "ft", LOG_FMT_FRONTEND_XPRT, PR_MODE_TCP, LW_INIT, NULL }, /* frontend with transport mode */
Willy Tarreaud9ed3d22014-06-13 12:23:06 +0200171 { "hr", LOG_FMT_HDRREQUEST, PR_MODE_TCP, LW_REQHDR, NULL }, /* header request */
172 { "hrl", LOG_FMT_HDRREQUESTLIST, PR_MODE_TCP, LW_REQHDR, NULL }, /* header request list */
173 { "hs", LOG_FMT_HDRRESPONS, PR_MODE_TCP, LW_RSPHDR, NULL }, /* header response */
174 { "hsl", LOG_FMT_HDRRESPONSLIST, PR_MODE_TCP, LW_RSPHDR, NULL }, /* header response list */
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +0000175 { "HM", LOG_FMT_HTTP_METHOD, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP method */
176 { "HP", LOG_FMT_HTTP_PATH, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP path */
Andrew Hayworthe63ac872015-07-31 16:14:16 +0000177 { "HQ", LOG_FMT_HTTP_QUERY, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP query */
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +0000178 { "HU", LOG_FMT_HTTP_URI, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP full URI */
179 { "HV", LOG_FMT_HTTP_VERSION, PR_MODE_HTTP, LW_REQ, NULL }, /* HTTP version */
Willy Tarreau7346acb2014-08-28 15:03:15 +0200180 { "lc", LOG_FMT_LOGCNT, PR_MODE_TCP, LW_INIT, NULL }, /* log counter */
Willy Tarreau2beef582012-12-20 17:22:52 +0100181 { "ms", LOG_FMT_MS, PR_MODE_TCP, LW_INIT, NULL }, /* accept date millisecond */
William Lallemand5e19a282012-04-02 16:22:10 +0200182 { "pid", LOG_FMT_PID, PR_MODE_TCP, LW_INIT, NULL }, /* log pid */
Willy Tarreau2beef582012-12-20 17:22:52 +0100183 { "r", LOG_FMT_REQ, PR_MODE_HTTP, LW_REQ, NULL }, /* request */
184 { "rc", LOG_FMT_RETRIES, PR_MODE_TCP, LW_BYTES, NULL }, /* retries */
Willy Tarreau1f0da242014-01-25 11:01:50 +0100185 { "rt", LOG_FMT_COUNTER, PR_MODE_TCP, LW_REQ, NULL }, /* request counter (HTTP or TCP session) */
Willy Tarreau2beef582012-12-20 17:22:52 +0100186 { "s", LOG_FMT_SERVER, PR_MODE_TCP, LW_SVID, NULL }, /* server */
187 { "sc", LOG_FMT_SRVCONN, PR_MODE_TCP, LW_BYTES, NULL }, /* srv_conn */
188 { "si", LOG_FMT_SERVERIP, PR_MODE_TCP, LW_SVIP, NULL }, /* server destination ip */
189 { "sp", LOG_FMT_SERVERPORT, PR_MODE_TCP, LW_SVIP, NULL }, /* server destination port */
190 { "sq", LOG_FMT_SRVQUEUE, PR_MODE_TCP, LW_BYTES, NULL }, /* srv_queue */
Willy Tarreauffc3fcd2012-10-12 20:17:54 +0200191 { "sslc", LOG_FMT_SSL_CIPHER, PR_MODE_TCP, LW_XPRT, NULL }, /* client-side SSL ciphers */
192 { "sslv", LOG_FMT_SSL_VERSION, PR_MODE_TCP, LW_XPRT, NULL }, /* client-side SSL protocol version */
Willy Tarreau2beef582012-12-20 17:22:52 +0100193 { "t", LOG_FMT_DATE, PR_MODE_TCP, LW_INIT, NULL }, /* date */
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +0200194 { "tr", LOG_FMT_tr, PR_MODE_HTTP, LW_INIT, NULL }, /* date of start of request */
195 { "trg",LOG_FMT_trg, PR_MODE_HTTP, LW_INIT, NULL }, /* date of start of request, GMT */
196 { "trl",LOG_FMT_trl, PR_MODE_HTTP, LW_INIT, NULL }, /* date of start of request, local */
Willy Tarreau2beef582012-12-20 17:22:52 +0100197 { "ts", LOG_FMT_TERMSTATE, PR_MODE_TCP, LW_BYTES, NULL },/* termination state */
198 { "tsc", LOG_FMT_TERMSTATE_CK, PR_MODE_TCP, LW_INIT, NULL },/* termination state */
199
200 /* The following tags are deprecated and will be removed soon */
201 { "Bi", LOG_FMT_BACKENDIP, PR_MODE_TCP, LW_BCKIP, prepare_addrsource, "bi" }, /* backend source ip */
202 { "Bp", LOG_FMT_BACKENDPORT, PR_MODE_TCP, LW_BCKIP, prepare_addrsource, "bp" }, /* backend source port */
Willy Tarreaud02286d2017-06-23 11:23:43 +0200203 { "Ci", LOG_FMT_CLIENTIP, PR_MODE_TCP, LW_CLIP | LW_XPRT, NULL, "ci" }, /* client ip */
204 { "Cp", LOG_FMT_CLIENTPORT, PR_MODE_TCP, LW_CLIP | LW_XPRT, NULL, "cp" }, /* client port */
205 { "Fi", LOG_FMT_FRONTENDIP, PR_MODE_TCP, LW_FRTIP | LW_XPRT, NULL, "fi" }, /* frontend ip */
206 { "Fp", LOG_FMT_FRONTENDPORT, PR_MODE_TCP, LW_FRTIP | LW_XPRT, NULL, "fp" }, /* frontend port */
Willy Tarreau2beef582012-12-20 17:22:52 +0100207 { "Si", LOG_FMT_SERVERIP, PR_MODE_TCP, LW_SVIP, NULL, "si" }, /* server destination ip */
208 { "Sp", LOG_FMT_SERVERPORT, PR_MODE_TCP, LW_SVIP, NULL, "sp" }, /* server destination port */
209 { "cc", LOG_FMT_CCLIENT, PR_MODE_HTTP, LW_REQHDR, NULL, "CC" }, /* client cookie */
210 { "cs", LOG_FMT_CSERVER, PR_MODE_HTTP, LW_RSPHDR, NULL, "CS" }, /* server cookie */
211 { "st", LOG_FMT_STATUS, PR_MODE_HTTP, LW_RESP, NULL, "ST" }, /* status code */
William Lallemand5e19a282012-04-02 16:22:10 +0200212 { 0, 0, 0, 0, NULL }
William Lallemand723b73a2012-02-08 16:37:49 +0100213};
214
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +0200215char 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
216char 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 +0100217char 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 +0100218char *log_format = NULL;
219
Dragan Dosen0b85ece2015-09-25 19:17:44 +0200220/* Default string used for structured-data part in RFC5424 formatted
221 * syslog messages.
222 */
223char default_rfc5424_sd_log_format[] = "- ";
Dragan Dosen1322d092015-09-22 16:05:32 +0200224
Willy Tarreau13ef7732018-11-12 07:25:28 +0100225/* total number of dropped logs */
226unsigned int dropped_logs = 0;
227
Dragan Dosen1322d092015-09-22 16:05:32 +0200228/* This is a global syslog header, common to all outgoing messages in
229 * RFC3164 format. It begins with time-based part and is updated by
230 * update_log_hdr().
Dragan Dosen59cee972015-09-19 22:09:02 +0200231 */
Christopher Fauletf8188c62017-06-02 16:20:16 +0200232THREAD_LOCAL char *logheader = NULL;
Willy Tarreau55e2f5a2019-05-05 10:11:39 +0200233THREAD_LOCAL char *logheader_end = NULL;
Dragan Dosen59cee972015-09-19 22:09:02 +0200234
Dragan Dosen1322d092015-09-22 16:05:32 +0200235/* This is a global syslog header for messages in RFC5424 format. It is
236 * updated by update_log_hdr_rfc5424().
237 */
Christopher Fauletf8188c62017-06-02 16:20:16 +0200238THREAD_LOCAL char *logheader_rfc5424 = NULL;
Willy Tarreau55e2f5a2019-05-05 10:11:39 +0200239THREAD_LOCAL char *logheader_rfc5424_end = NULL;
Dragan Dosen1322d092015-09-22 16:05:32 +0200240
Dragan Dosen59cee972015-09-19 22:09:02 +0200241/* This is a global syslog message buffer, common to all outgoing
242 * messages. It contains only the data part.
Willy Tarreaub1a2faf2012-03-19 16:51:53 +0100243 */
Christopher Fauletf8188c62017-06-02 16:20:16 +0200244THREAD_LOCAL char *logline = NULL;
Willy Tarreaub1a2faf2012-03-19 16:51:53 +0100245
Dragan Dosen0b85ece2015-09-25 19:17:44 +0200246/* A global syslog message buffer, common to all RFC5424 syslog messages.
247 * Currently, it is used for generating the structured-data part.
248 */
Christopher Fauletf8188c62017-06-02 16:20:16 +0200249THREAD_LOCAL char *logline_rfc5424 = NULL;
Dragan Dosen0b85ece2015-09-25 19:17:44 +0200250
Christopher Fauletd4696382017-10-24 11:44:05 +0200251/* A global buffer used to store all startup alerts/warnings. It will then be
252 * retrieve on the CLI. */
Willy Tarreaua6483992018-12-15 16:55:36 +0100253static char *startup_logs = NULL;
Christopher Fauletd4696382017-10-24 11:44:05 +0200254
William Lallemand723b73a2012-02-08 16:37:49 +0100255struct logformat_var_args {
256 char *name;
257 int mask;
258};
259
260struct logformat_var_args var_args_list[] = {
261// global
262 { "M", LOG_OPT_MANDATORY },
263 { "Q", LOG_OPT_QUOTE },
William Lallemand5f232402012-04-05 18:02:55 +0200264 { "X", LOG_OPT_HEXA },
Dragan Dosen835b9212016-02-12 13:23:03 +0100265 { "E", LOG_OPT_ESC },
William Lallemand723b73a2012-02-08 16:37:49 +0100266 { 0, 0 }
267};
268
Willy Tarreaub1f3af22013-04-12 18:30:32 +0200269/* return the name of the directive used in the current proxy for which we're
270 * currently parsing a header, when it is known.
271 */
272static inline const char *fmt_directive(const struct proxy *curproxy)
273{
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100274 switch (curproxy->conf.args.ctx) {
Willy Tarreau53e1a6d2015-07-09 11:20:00 +0200275 case ARGC_ACL:
276 return "acl";
277 case ARGC_STK:
278 return "stick";
279 case ARGC_TRK:
280 return "track-sc";
281 case ARGC_LOG:
282 return "log-format";
Dragan Dosen0b85ece2015-09-25 19:17:44 +0200283 case ARGC_LOGSD:
284 return "log-format-sd";
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100285 case ARGC_HRQ:
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +0100286 return "http-request";
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100287 case ARGC_HRS:
Thierry FOURNIER1c0054f2013-11-20 15:09:52 +0100288 return "http-response";
Willy Tarreau53e1a6d2015-07-09 11:20:00 +0200289 case ARGC_UIF:
290 return "unique-id-format";
Thierry FOURNIERd18cd0f2013-11-29 12:15:45 +0100291 case ARGC_RDR:
Willy Tarreau53e1a6d2015-07-09 11:20:00 +0200292 return "redirect";
293 case ARGC_CAP:
294 return "capture";
Willy Tarreau28d976d2015-07-09 11:39:33 +0200295 case ARGC_SRV:
296 return "server";
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +0200297 case ARGC_SPOE:
298 return "spoe-message";
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +0100299 case ARGC_UBK:
300 return "use_backend";
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100301 default:
Willy Tarreau53e1a6d2015-07-09 11:20:00 +0200302 return "undefined(please report this bug)"; /* must never happen */
Willy Tarreaubf0addb2013-12-02 12:24:54 +0100303 }
Willy Tarreaub1f3af22013-04-12 18:30:32 +0200304}
305
William Lallemand723b73a2012-02-08 16:37:49 +0100306/*
William Lallemandb7ff6a32012-03-02 14:35:21 +0100307 * callback used to configure addr source retrieval
308 */
309int prepare_addrsource(struct logformat_node *node, struct proxy *curproxy)
310{
311 curproxy->options2 |= PR_O2_SRC_ADDR;
312
313 return 0;
314}
315
316
317/*
Thierry FOURNIER / OZON.IObca46f02016-11-22 23:13:04 +0100318 * Parse args in a logformat_var. Returns 0 in error
319 * case, otherwise, it returns 1.
William Lallemand723b73a2012-02-08 16:37:49 +0100320 */
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100321int parse_logformat_var_args(char *args, struct logformat_node *node, char **err)
William Lallemand723b73a2012-02-08 16:37:49 +0100322{
323 int i = 0;
324 int end = 0;
325 int flags = 0; // 1 = + 2 = -
326 char *sp = NULL; // start pointer
327
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100328 if (args == NULL) {
329 memprintf(err, "internal error: parse_logformat_var_args() expects non null 'args'");
Thierry FOURNIER / OZON.IObca46f02016-11-22 23:13:04 +0100330 return 0;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100331 }
William Lallemand723b73a2012-02-08 16:37:49 +0100332
333 while (1) {
334 if (*args == '\0')
335 end = 1;
336
337 if (*args == '+') {
338 // add flag
339 sp = args + 1;
340 flags = 1;
341 }
342 if (*args == '-') {
343 // delete flag
344 sp = args + 1;
345 flags = 2;
346 }
347
348 if (*args == '\0' || *args == ',') {
349 *args = '\0';
Willy Tarreau254d44c2012-12-20 18:19:26 +0100350 for (i = 0; sp && var_args_list[i].name; i++) {
William Lallemand723b73a2012-02-08 16:37:49 +0100351 if (strcmp(sp, var_args_list[i].name) == 0) {
352 if (flags == 1) {
353 node->options |= var_args_list[i].mask;
354 break;
355 } else if (flags == 2) {
356 node->options &= ~var_args_list[i].mask;
357 break;
358 }
359 }
360 }
361 sp = NULL;
362 if (end)
363 break;
364 }
Willy Tarreau254d44c2012-12-20 18:19:26 +0100365 args++;
William Lallemand723b73a2012-02-08 16:37:49 +0100366 }
Thierry FOURNIER / OZON.IObca46f02016-11-22 23:13:04 +0100367 return 1;
William Lallemand723b73a2012-02-08 16:37:49 +0100368}
369
370/*
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100371 * Parse a variable '%varname' or '%{args}varname' in log-format. The caller
372 * must pass the args part in the <arg> pointer with its length in <arg_len>,
373 * and varname with its length in <var> and <var_len> respectively. <arg> is
374 * ignored when arg_len is 0. Neither <var> nor <var_len> may be null.
Thierry FOURNIER / OZON.IOeca4d952016-11-22 22:06:04 +0100375 * Returns false in error case and err is filled, otherwise returns true.
William Lallemand723b73a2012-02-08 16:37:49 +0100376 */
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100377int 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 +0100378{
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100379 int j;
Dragan Dosen61302da2019-04-30 00:40:02 +0200380 struct logformat_node *node = NULL;
William Lallemand723b73a2012-02-08 16:37:49 +0100381
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100382 for (j = 0; logformat_keywords[j].name; j++) { // search a log type
383 if (strlen(logformat_keywords[j].name) == var_len &&
384 strncmp(var, logformat_keywords[j].name, var_len) == 0) {
385 if (logformat_keywords[j].mode != PR_MODE_HTTP || curproxy->mode == PR_MODE_HTTP) {
Vincent Bernat02779b62016-04-03 13:48:43 +0200386 node = calloc(1, sizeof(*node));
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100387 if (!node) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100388 memprintf(err, "out of memory error");
Dragan Dosen61302da2019-04-30 00:40:02 +0200389 goto error_free;
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100390 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100391 node->type = logformat_keywords[j].type;
392 node->options = *defoptions;
393 if (arg_len) {
394 node->arg = my_strndup(arg, arg_len);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100395 if (!parse_logformat_var_args(node->arg, node, err))
Dragan Dosen61302da2019-04-30 00:40:02 +0200396 goto error_free;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100397 }
398 if (node->type == LOG_FMT_GLOBAL) {
399 *defoptions = node->options;
400 free(node->arg);
401 free(node);
402 } else {
403 if (logformat_keywords[j].config_callback &&
404 logformat_keywords[j].config_callback(node, curproxy) != 0) {
Dragan Dosen61302da2019-04-30 00:40:02 +0200405 goto error_free;
William Lallemand723b73a2012-02-08 16:37:49 +0100406 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100407 curproxy->to_log |= logformat_keywords[j].lw;
408 LIST_ADDQ(list_format, &node->list);
William Lallemand723b73a2012-02-08 16:37:49 +0100409 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100410 if (logformat_keywords[j].replace_by)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100411 ha_warning("parsing [%s:%d] : deprecated variable '%s' in '%s', please replace it with '%s'.\n",
412 curproxy->conf.args.file, curproxy->conf.args.line,
413 logformat_keywords[j].name, fmt_directive(curproxy), logformat_keywords[j].replace_by);
Thierry FOURNIER / OZON.IOeca4d952016-11-22 22:06:04 +0100414 return 1;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100415 } else {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100416 memprintf(err, "format variable '%s' is reserved for HTTP mode",
417 logformat_keywords[j].name);
Dragan Dosen61302da2019-04-30 00:40:02 +0200418 goto error_free;
William Lallemand723b73a2012-02-08 16:37:49 +0100419 }
William Lallemand723b73a2012-02-08 16:37:49 +0100420 }
421 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100422
423 j = var[var_len];
424 var[var_len] = 0;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100425 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 +0100426 var[var_len] = j;
Dragan Dosen61302da2019-04-30 00:40:02 +0200427
428 error_free:
429 if (node) {
430 free(node->arg);
431 free(node);
432 }
Thierry FOURNIER / OZON.IOeca4d952016-11-22 22:06:04 +0100433 return 0;
William Lallemand723b73a2012-02-08 16:37:49 +0100434}
435
436/*
437 * push to the logformat linked list
438 *
439 * start: start pointer
440 * end: end text pointer
441 * type: string type
William Lallemand1d705562012-03-12 12:46:41 +0100442 * list_format: destination list
William Lallemand723b73a2012-02-08 16:37:49 +0100443 *
444 * LOG_TEXT: copy chars from start to end excluding end.
445 *
446*/
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100447int add_to_logformat_list(char *start, char *end, int type, struct list *list_format, char **err)
William Lallemand723b73a2012-02-08 16:37:49 +0100448{
449 char *str;
450
Willy Tarreaua3571662012-12-20 21:59:12 +0100451 if (type == LF_TEXT) { /* type text */
Vincent Bernat02779b62016-04-03 13:48:43 +0200452 struct logformat_node *node = calloc(1, sizeof(*node));
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100453 if (!node) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100454 memprintf(err, "out of memory error");
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100455 return 0;
456 }
Vincent Bernat02779b62016-04-03 13:48:43 +0200457 str = calloc(1, end - start + 1);
William Lallemand723b73a2012-02-08 16:37:49 +0100458 strncpy(str, start, end - start);
William Lallemand723b73a2012-02-08 16:37:49 +0100459 str[end - start] = '\0';
460 node->arg = str;
William Lallemand1d705562012-03-12 12:46:41 +0100461 node->type = LOG_FMT_TEXT; // type string
462 LIST_ADDQ(list_format, &node->list);
Willy Tarreaua3571662012-12-20 21:59:12 +0100463 } else if (type == LF_SEPARATOR) {
Vincent Bernat02779b62016-04-03 13:48:43 +0200464 struct logformat_node *node = calloc(1, sizeof(*node));
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100465 if (!node) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100466 memprintf(err, "out of memory error");
Thierry FOURNIER / OZON.IO9cbfef22016-11-22 23:24:10 +0100467 return 0;
468 }
William Lallemand1d705562012-03-12 12:46:41 +0100469 node->type = LOG_FMT_SEPARATOR;
470 LIST_ADDQ(list_format, &node->list);
William Lallemand723b73a2012-02-08 16:37:49 +0100471 }
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100472 return 1;
William Lallemand723b73a2012-02-08 16:37:49 +0100473}
474
475/*
Willy Tarreauc8368452012-12-21 00:09:23 +0100476 * Parse the sample fetch expression <text> and add a node to <list_format> upon
477 * success. At the moment, sample converters are not yet supported but fetch arguments
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200478 * should work. The curpx->conf.args.ctx must be set by the caller.
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 */
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +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)
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
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100493 expr = sample_parse_expr(cmd, &cmd_arg, curpx->conf.args.file, curpx->conf.args.line, err, &curpx->conf.args);
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
Willy Tarreauc8368452012-12-21 00:09:23 +0100525 /* check if we need to allocate an hdr_idx struct for HTTP parsing */
526 /* 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);
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100623 return 0;
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);
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100650 return 0;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100651
Willy Tarreauc8368452012-12-21 00:09:23 +0100652 case LF_STEXPR: // text immediately following '%['
653 if (*str == ']') { // end of arg
654 cformat = LF_EDEXPR;
655 var_len = str - var;
656 *str = 0; // needed for parsing the expression
657 }
658 break;
659
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100660 case LF_VAR: // text part of a variable name
661 var_len = str - var;
Willy Tarreau0f28f822013-12-16 01:38:33 +0100662 if (!isalnum((unsigned char)*str))
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100663 cformat = LF_INIT; // not variable name anymore
664 break;
665
Willy Tarreauc8368452012-12-21 00:09:23 +0100666 default: // LF_INIT, LF_TEXT, LF_SEPARATOR, LF_END, LF_EDEXPR
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100667 cformat = LF_INIT;
668 }
669
670 if (cformat == LF_INIT) { /* resynchronize state to text/sep/startvar */
671 switch (*str) {
672 case '%': cformat = LF_STARTVAR; break;
673 case ' ': cformat = LF_SEPARATOR; break;
674 case 0 : cformat = LF_END; break;
675 default : cformat = LF_TEXT; break;
William Lallemand723b73a2012-02-08 16:37:49 +0100676 }
677 }
678
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100679 if (cformat != pformat || pformat == LF_SEPARATOR) {
680 switch (pformat) {
681 case LF_VAR:
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100682 if (!parse_logformat_var(arg, arg_len, var, var_len, curproxy, list_format, &options, err))
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100683 return 0;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100684 break;
Willy Tarreauc8368452012-12-21 00:09:23 +0100685 case LF_STEXPR:
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100686 if (!add_sample_to_logformat_list(var, arg, arg_len, curproxy, list_format, options, cap, err))
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100687 return 0;
Willy Tarreauc8368452012-12-21 00:09:23 +0100688 break;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100689 case LF_TEXT:
690 case LF_SEPARATOR:
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100691 if (!add_to_logformat_list(sp, str, pformat, list_format, err))
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100692 return 0;
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100693 break;
694 }
695 sp = str; /* new start of text at every state switch and at every separator */
William Lallemand723b73a2012-02-08 16:37:49 +0100696 }
697 }
Willy Tarreau8a3f52f2012-12-20 21:23:42 +0100698
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100699 if (pformat == LF_STARTVAR || pformat == LF_STARG || pformat == LF_STEXPR) {
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +0100700 memprintf(err, "truncated line after '%s'", var ? var : arg ? arg : "%");
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100701 return 0;
702 }
Willy Tarreaub83bc1e2012-12-24 12:36:33 +0100703 free(backfmt);
Thierry FOURNIER / OZON.IOa2c38d72016-11-22 23:11:21 +0100704
705 return 1;
William Lallemand723b73a2012-02-08 16:37:49 +0100706}
707
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200708/*
Frédéric Lécailled95ea282019-04-24 16:14:33 +0200709 * Parse the first range of indexes from a string made of a list of comma seperated
710 * ranges of indexes. Note that an index may be considered as a particular range
711 * with a high limit to the low limit.
712 */
713int get_logsrv_smp_range(unsigned int *low, unsigned int *high, char **arg, char **err)
714{
715 char *end, *p;
716
717 *low = *high = 0;
718
719 p = *arg;
720 end = strchr(p, ',');
721 if (!end)
722 end = p + strlen(p);
723
724 *high = *low = read_uint((const char **)&p, end);
725 if (!*low || (p != end && *p != '-'))
726 goto err;
727
728 if (p == end)
729 goto done;
730
731 p++;
732 *high = read_uint((const char **)&p, end);
733 if (!*high || *high <= *low || p != end)
734 goto err;
735
736 done:
737 if (*end == ',')
738 end++;
739 *arg = end;
740 return 1;
741
742 err:
743 memprintf(err, "wrong sample range '%s'", *arg);
744 return 0;
745}
746
747/*
748 * Returns 1 if the range defined by <low> and <high> overlaps
749 * one of them in <rgs> array of ranges with <sz> the size of this
750 * array, 0 if not.
751 */
752int smp_log_ranges_overlap(struct smp_log_range *rgs, size_t sz,
753 unsigned int low, unsigned int high, char **err)
754{
755 size_t i;
756
757 for (i = 0; i < sz; i++) {
758 if ((low >= rgs[i].low && low <= rgs[i].high) ||
759 (high >= rgs[i].low && high <= rgs[i].high)) {
760 memprintf(err, "ranges are overlapping");
761 return 1;
762 }
763 }
764
765 return 0;
766}
767
768int smp_log_range_cmp(const void *a, const void *b)
769{
770 const struct smp_log_range *rg_a = a;
771 const struct smp_log_range *rg_b = b;
772
773 if (rg_a->high < rg_b->low)
774 return -1;
775 else if (rg_a->low > rg_b->high)
776 return 1;
777
778 return 0;
779}
780
781/*
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200782 * Parse "log" keyword and update <logsrvs> list accordingly.
783 *
784 * When <do_del> is set, it means the "no log" line was parsed, so all log
785 * servers in <logsrvs> are released.
786 *
787 * Otherwise, we try to parse the "log" line. First of all, when the list is not
788 * the global one, we look for the parameter "global". If we find it,
789 * global.logsrvs is copied. Else we parse each arguments.
790 *
791 * The function returns 1 in success case, otherwise, it returns 0 and err is
792 * filled.
793 */
794int parse_logsrv(char **args, struct list *logsrvs, int do_del, char **err)
795{
796 struct sockaddr_storage *sk;
797 struct logsrv *logsrv = NULL;
798 int port1, port2;
799 int cur_arg;
800
801 /*
802 * "no log": delete previous herited or defined syslog
803 * servers.
804 */
805 if (do_del) {
806 struct logsrv *back;
807
808 if (*(args[1]) != 0) {
809 memprintf(err, "'no log' does not expect arguments");
810 goto error;
811 }
812
813 list_for_each_entry_safe(logsrv, back, logsrvs, list) {
814 LIST_DEL(&logsrv->list);
815 free(logsrv);
816 }
817 return 1;
818 }
819
820 /*
821 * "log global": copy global.logrsvs linked list to the end of logsrvs
822 * list. But first, we check (logsrvs != global.logsrvs).
823 */
824 if (*(args[1]) && *(args[2]) == 0 && !strcmp(args[1], "global")) {
825 if (logsrvs == &global.logsrvs) {
826 memprintf(err, "'global' is not supported for a global syslog server");
827 goto error;
828 }
829 list_for_each_entry(logsrv, &global.logsrvs, list) {
Christopher Faulet28ac0992018-03-26 16:09:19 +0200830 struct logsrv *node;
831
832 list_for_each_entry(node, logsrvs, list) {
833 if (node->ref == logsrv)
834 goto skip_logsrv;
835 }
836
837 node = malloc(sizeof(*node));
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200838 memcpy(node, logsrv, sizeof(struct logsrv));
Christopher Faulet28ac0992018-03-26 16:09:19 +0200839 node->ref = logsrv;
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200840 LIST_INIT(&node->list);
841 LIST_ADDQ(logsrvs, &node->list);
Christopher Faulet28ac0992018-03-26 16:09:19 +0200842
843 skip_logsrv:
844 continue;
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200845 }
846 return 1;
847 }
848
849 /*
850 * "log <address> ...: parse a syslog server line
851 */
852 if (*(args[1]) == 0 || *(args[2]) == 0) {
853 memprintf(err, "expects <address> and <facility> %s as arguments",
854 ((logsrvs == &global.logsrvs) ? "" : "or global"));
855 goto error;
856 }
857
Willy Tarreau5a32ecc2018-11-12 07:34:59 +0100858 /* take care of "stdout" and "stderr" as regular aliases for fd@1 / fd@2 */
859 if (strcmp(args[1], "stdout") == 0)
860 args[1] = "fd@1";
861 else if (strcmp(args[1], "stderr") == 0)
862 args[1] = "fd@2";
863
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200864 logsrv = calloc(1, sizeof(*logsrv));
865 if (!logsrv) {
866 memprintf(err, "out of memory");
867 goto error;
868 }
869
870 /* skip address for now, it will be parsed at the end */
871 cur_arg = 2;
872
873 /* just after the address, a length may be specified */
874 logsrv->maxlen = MAX_SYSLOG_LEN;
875 if (strcmp(args[cur_arg], "len") == 0) {
876 int len = atoi(args[cur_arg+1]);
877 if (len < 80 || len > 65535) {
878 memprintf(err, "invalid log length '%s', must be between 80 and 65535",
879 args[cur_arg+1]);
880 goto error;
881 }
882 logsrv->maxlen = len;
883 cur_arg += 2;
884 }
885 if (logsrv->maxlen > global.max_syslog_len)
886 global.max_syslog_len = logsrv->maxlen;
887
888 /* after the length, a format may be specified */
889 if (strcmp(args[cur_arg], "format") == 0) {
890 logsrv->format = get_log_format(args[cur_arg+1]);
891 if (logsrv->format < 0) {
892 memprintf(err, "unknown log format '%s'", args[cur_arg+1]);
893 goto error;
894 }
895 cur_arg += 2;
896 }
897
Frédéric Lécailled95ea282019-04-24 16:14:33 +0200898 if (strcmp(args[cur_arg], "sample") == 0) {
899 unsigned low, high;
900 char *p, *beg, *end, *smp_sz_str;
901 struct smp_log_range *smp_rgs = NULL;
902 size_t smp_rgs_sz = 0, smp_sz = 0, new_smp_sz;
903
904 p = args[cur_arg+1];
905 smp_sz_str = strchr(p, ':');
906 if (!smp_sz_str) {
907 memprintf(err, "Missing sample size");
908 goto error;
909 }
910
911 *smp_sz_str++ = '\0';
912
913 end = p + strlen(p);
914
915 while (p != end) {
916 if (!get_logsrv_smp_range(&low, &high, &p, err))
917 goto error;
918
919 if (smp_rgs && smp_log_ranges_overlap(smp_rgs, smp_rgs_sz, low, high, err))
920 goto error;
921
922 smp_rgs = my_realloc2(smp_rgs, (smp_rgs_sz + 1) * sizeof *smp_rgs);
923 if (!smp_rgs) {
924 memprintf(err, "out of memory error");
925 goto error;
926 }
927
928 smp_rgs[smp_rgs_sz].low = low;
929 smp_rgs[smp_rgs_sz].high = high;
930 smp_rgs[smp_rgs_sz].sz = high - low + 1;
931 smp_rgs[smp_rgs_sz].curr_idx = 0;
932 if (smp_rgs[smp_rgs_sz].high > smp_sz)
933 smp_sz = smp_rgs[smp_rgs_sz].high;
934 smp_rgs_sz++;
935 }
936
937 beg = smp_sz_str;
938 end = beg + strlen(beg);
939 new_smp_sz = read_uint((const char **)&beg, end);
940 if (!new_smp_sz || beg != end) {
941 memprintf(err, "wrong sample size '%s' for sample range '%s'",
942 smp_sz_str, args[cur_arg+1]);
943 goto error;
944 }
945
946 if (new_smp_sz < smp_sz) {
947 memprintf(err, "sample size %zu should be greater or equal to "
948 "%zu the maximum of the high ranges limits",
949 new_smp_sz, smp_sz);
950 goto error;
951 }
952 smp_sz = new_smp_sz;
953
954 /* Let's order <smp_rgs> array. */
955 qsort(smp_rgs, smp_rgs_sz, sizeof(struct smp_log_range), smp_log_range_cmp);
956
957 logsrv->lb.smp_rgs = smp_rgs;
958 logsrv->lb.smp_rgs_sz = smp_rgs_sz;
959 logsrv->lb.smp_sz = smp_sz;
960
961 cur_arg += 2;
962 }
Frédéric Lécailled803e472019-04-25 07:42:09 +0200963 HA_SPIN_INIT(&logsrv->lock);
Christopher Faulet4b0b79d2018-03-26 15:54:32 +0200964 /* parse the facility */
965 logsrv->facility = get_log_facility(args[cur_arg]);
966 if (logsrv->facility < 0) {
967 memprintf(err, "unknown log facility '%s'", args[cur_arg]);
968 goto error;
969 }
970 cur_arg++;
971
972 /* parse the max syslog level (default: debug) */
973 logsrv->level = 7;
974 if (*(args[cur_arg])) {
975 logsrv->level = get_log_level(args[cur_arg]);
976 if (logsrv->level < 0) {
977 memprintf(err, "unknown optional log level '%s'", args[cur_arg]);
978 goto error;
979 }
980 cur_arg++;
981 }
982
983 /* parse the limit syslog level (default: emerg) */
984 logsrv->minlvl = 0;
985 if (*(args[cur_arg])) {
986 logsrv->minlvl = get_log_level(args[cur_arg]);
987 if (logsrv->minlvl < 0) {
988 memprintf(err, "unknown optional minimum log level '%s'", args[cur_arg]);
989 goto error;
990 }
991 cur_arg++;
992 }
993
994 /* Too many args */
995 if (*(args[cur_arg])) {
996 memprintf(err, "cannot handle unexpected argument '%s'", args[cur_arg]);
997 goto error;
998 }
999
1000 /* now, back to the address */
1001 sk = str2sa_range(args[1], NULL, &port1, &port2, err, NULL, NULL, 1);
1002 if (!sk)
1003 goto error;
1004 logsrv->addr = *sk;
1005
1006 if (sk->ss_family == AF_INET || sk->ss_family == AF_INET6) {
1007 if (port1 != port2) {
1008 memprintf(err, "port ranges and offsets are not allowed in '%s'", args[1]);
1009 goto error;
1010 }
1011 logsrv->addr = *sk;
1012 if (!port1)
1013 set_host_port(&logsrv->addr, SYSLOG_PORT);
1014 }
1015 LIST_ADDQ(logsrvs, &logsrv->list);
1016 return 1;
1017
1018 error:
1019 free(logsrv);
1020 return 0;
1021}
1022
1023
Christopher Fauletd4696382017-10-24 11:44:05 +02001024/* Generic function to display messages prefixed by a label */
1025static void print_message(const char *label, const char *fmt, va_list argp)
1026{
1027 struct tm tm;
1028 char *head, *msg;
1029
1030 head = msg = NULL;
1031
1032 get_localtime(date.tv_sec, &tm);
1033 memprintf(&head, "[%s] %03d/%02d%02d%02d (%d) : ",
1034 label, tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec, (int)getpid());
1035 memvprintf(&msg, fmt, argp);
1036
1037 if (global.mode & MODE_STARTING)
1038 memprintf(&startup_logs, "%s%s%s", (startup_logs ? startup_logs : ""), head, msg);
1039
1040 fprintf(stderr, "%s%s", head, msg);
1041 fflush(stderr);
1042
1043 free(head);
1044 free(msg);
1045}
1046
Willy Tarreaubaaee002006-06-26 02:48:02 +02001047/*
1048 * Displays the message on stderr with the date and pid. Overrides the quiet
1049 * mode during startup.
1050 */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001051void ha_alert(const char *fmt, ...)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001052{
1053 va_list argp;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001054
1055 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
1056 va_start(argp, fmt);
Christopher Fauletd4696382017-10-24 11:44:05 +02001057 print_message("ALERT", fmt, argp);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001058 va_end(argp);
1059 }
1060}
1061
1062
1063/*
1064 * Displays the message on stderr with the date and pid.
1065 */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001066void ha_warning(const char *fmt, ...)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001067{
1068 va_list argp;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001069
1070 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
1071 va_start(argp, fmt);
Christopher Fauletd4696382017-10-24 11:44:05 +02001072 print_message("WARNING", fmt, argp);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001073 va_end(argp);
1074 }
1075}
1076
1077/*
William Lallemand9c56a222018-11-21 18:04:52 +01001078 * Displays the message on stderr with the date and pid.
1079 */
1080void ha_notice(const char *fmt, ...)
1081{
1082 va_list argp;
1083
1084 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
1085 va_start(argp, fmt);
1086 print_message("NOTICE", fmt, argp);
1087 va_end(argp);
1088 }
1089}
1090
1091/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001092 * Displays the message on <out> only if quiet mode is not set.
1093 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001094void qfprintf(FILE *out, const char *fmt, ...)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001095{
1096 va_list argp;
1097
1098 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
1099 va_start(argp, fmt);
1100 vfprintf(out, fmt, argp);
1101 fflush(out);
1102 va_end(argp);
1103 }
1104}
1105
1106/*
Dragan Dosen1322d092015-09-22 16:05:32 +02001107 * returns log format for <fmt> or -1 if not found.
1108 */
1109int get_log_format(const char *fmt)
1110{
1111 int format;
1112
1113 format = LOG_FORMATS - 1;
Dragan Dosen43885c72015-10-01 13:18:13 +02001114 while (format >= 0 && strcmp(log_formats[format].name, fmt))
Dragan Dosen1322d092015-09-22 16:05:32 +02001115 format--;
1116
1117 return format;
1118}
1119
1120/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001121 * returns log level for <lev> or -1 if not found.
1122 */
1123int get_log_level(const char *lev)
1124{
1125 int level;
1126
1127 level = NB_LOG_LEVELS - 1;
1128 while (level >= 0 && strcmp(log_levels[level], lev))
1129 level--;
1130
1131 return level;
1132}
1133
Willy Tarreaubaaee002006-06-26 02:48:02 +02001134/*
1135 * returns log facility for <fac> or -1 if not found.
1136 */
1137int get_log_facility(const char *fac)
1138{
1139 int facility;
1140
1141 facility = NB_LOG_FACILITIES - 1;
1142 while (facility >= 0 && strcmp(log_facilities[facility], fac))
1143 facility--;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001144
Willy Tarreaubaaee002006-06-26 02:48:02 +02001145 return facility;
1146}
1147
William Lallemanda1cc3812012-02-08 16:38:44 +01001148/*
Dragan Dosen835b9212016-02-12 13:23:03 +01001149 * Encode the string.
1150 *
1151 * When using the +E log format option, it will try to escape '"\]'
1152 * characters with '\' as prefix. The same prefix should not be used as
1153 * <escape>.
1154 */
1155static char *lf_encode_string(char *start, char *stop,
1156 const char escape, const fd_set *map,
1157 const char *string,
1158 struct logformat_node *node)
1159{
1160 if (node->options & LOG_OPT_ESC) {
1161 if (start < stop) {
1162 stop--; /* reserve one byte for the final '\0' */
1163 while (start < stop && *string != '\0') {
1164 if (!FD_ISSET((unsigned char)(*string), map)) {
1165 if (!FD_ISSET((unsigned char)(*string), rfc5424_escape_map))
1166 *start++ = *string;
1167 else {
1168 if (start + 2 >= stop)
1169 break;
1170 *start++ = '\\';
1171 *start++ = *string;
1172 }
1173 }
1174 else {
1175 if (start + 3 >= stop)
1176 break;
1177 *start++ = escape;
1178 *start++ = hextab[(*string >> 4) & 15];
1179 *start++ = hextab[*string & 15];
1180 }
1181 string++;
1182 }
1183 *start = '\0';
1184 }
1185 }
1186 else {
1187 return encode_string(start, stop, escape, map, string);
1188 }
1189
1190 return start;
1191}
1192
1193/*
1194 * Encode the chunk.
1195 *
1196 * When using the +E log format option, it will try to escape '"\]'
1197 * characters with '\' as prefix. The same prefix should not be used as
1198 * <escape>.
1199 */
1200static char *lf_encode_chunk(char *start, char *stop,
1201 const char escape, const fd_set *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001202 const struct buffer *chunk,
Dragan Dosen835b9212016-02-12 13:23:03 +01001203 struct logformat_node *node)
1204{
1205 char *str, *end;
1206
1207 if (node->options & LOG_OPT_ESC) {
1208 if (start < stop) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001209 str = chunk->area;
1210 end = chunk->area + chunk->data;
Dragan Dosen835b9212016-02-12 13:23:03 +01001211
1212 stop--; /* reserve one byte for the final '\0' */
1213 while (start < stop && str < end) {
1214 if (!FD_ISSET((unsigned char)(*str), map)) {
1215 if (!FD_ISSET((unsigned char)(*str), rfc5424_escape_map))
1216 *start++ = *str;
1217 else {
1218 if (start + 2 >= stop)
1219 break;
1220 *start++ = '\\';
1221 *start++ = *str;
1222 }
1223 }
1224 else {
1225 if (start + 3 >= stop)
1226 break;
1227 *start++ = escape;
1228 *start++ = hextab[(*str >> 4) & 15];
1229 *start++ = hextab[*str & 15];
1230 }
1231 str++;
1232 }
1233 *start = '\0';
1234 }
1235 }
1236 else {
1237 return encode_chunk(start, stop, escape, map, chunk);
1238 }
1239
1240 return start;
1241}
1242
1243/*
William Lallemanda1cc3812012-02-08 16:38:44 +01001244 * Write a string in the log string
Dragan Dosen835b9212016-02-12 13:23:03 +01001245 * Take cares of quote and escape options
William Lallemanda1cc3812012-02-08 16:38:44 +01001246 *
Joseph Herlant85b40592018-11-15 12:10:04 -08001247 * Return the address of the \0 character, or NULL on error
William Lallemanda1cc3812012-02-08 16:38:44 +01001248 */
Willy Tarreau26ffa852018-09-05 15:23:10 +02001249char *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 +01001250{
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001251 if (size < 2)
1252 return NULL;
William Lallemanda1cc3812012-02-08 16:38:44 +01001253
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001254 if (node->options & LOG_OPT_QUOTE) {
1255 *(dst++) = '"';
1256 size--;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001257 }
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001258
Willy Tarreau6cbbdbf2013-02-05 18:52:25 +01001259 if (src && len) {
Dragan Dosendb1b6f92016-07-25 11:35:02 +02001260 if (++len > size)
1261 len = size;
Dragan Dosen835b9212016-02-12 13:23:03 +01001262 if (node->options & LOG_OPT_ESC) {
Dragan Dosen835b9212016-02-12 13:23:03 +01001263 char *ret;
1264
Dragan Dosendb1b6f92016-07-25 11:35:02 +02001265 ret = escape_string(dst, dst + len, '\\', rfc5424_escape_map, src);
Dragan Dosen835b9212016-02-12 13:23:03 +01001266 if (ret == NULL || *ret != '\0')
1267 return NULL;
1268 len = ret - dst;
1269 }
1270 else {
Dragan Dosen835b9212016-02-12 13:23:03 +01001271 len = strlcpy2(dst, src, len);
1272 }
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001273
1274 size -= len;
1275 dst += len;
1276 }
Willy Tarreau6cbbdbf2013-02-05 18:52:25 +01001277 else if ((node->options & (LOG_OPT_QUOTE|LOG_OPT_MANDATORY)) == LOG_OPT_MANDATORY) {
1278 if (size < 2)
1279 return NULL;
1280 *(dst++) = '-';
1281 }
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001282
1283 if (node->options & LOG_OPT_QUOTE) {
1284 if (size < 2)
1285 return NULL;
1286 *(dst++) = '"';
1287 }
1288
1289 *dst = '\0';
William Lallemandbddd4fd2012-02-27 11:23:10 +01001290 return dst;
William Lallemanda1cc3812012-02-08 16:38:44 +01001291}
1292
Willy Tarreau26ffa852018-09-05 15:23:10 +02001293static inline char *lf_text(char *dst, const char *src, size_t size, const struct logformat_node *node)
Willy Tarreau2b0108a2012-12-21 19:23:44 +01001294{
1295 return lf_text_len(dst, src, size, size, node);
1296}
1297
William Lallemand5f232402012-04-05 18:02:55 +02001298/*
Joseph Herlant85b40592018-11-15 12:10:04 -08001299 * Write a IP address to the log string
William Lallemand5f232402012-04-05 18:02:55 +02001300 * +X option write in hexadecimal notation, most signifant byte on the left
1301 */
Willy Tarreau26ffa852018-09-05 15:23:10 +02001302char *lf_ip(char *dst, const struct sockaddr *sockaddr, size_t size, const struct logformat_node *node)
William Lallemand5f232402012-04-05 18:02:55 +02001303{
1304 char *ret = dst;
1305 int iret;
1306 char pn[INET6_ADDRSTRLEN];
1307
1308 if (node->options & LOG_OPT_HEXA) {
Radek Zajic594c4562019-03-22 10:21:54 +00001309 unsigned char *addr = NULL;
1310 switch (sockaddr->sa_family) {
1311 case AF_INET:
1312 addr = (unsigned char *)&((struct sockaddr_in *)sockaddr)->sin_addr.s_addr;
1313 iret = snprintf(dst, size, "%02X%02X%02X%02X", addr[0], addr[1], addr[2], addr[3]);
1314 break;
1315 case AF_INET6:
1316 addr = (unsigned char *)&((struct sockaddr_in6 *)sockaddr)->sin6_addr.s6_addr;
1317 iret = snprintf(dst, size, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
1318 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
1319 addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15]);
1320 break;
1321 default:
1322 return NULL;
1323 }
William Lallemand5f232402012-04-05 18:02:55 +02001324 if (iret < 0 || iret > size)
1325 return NULL;
1326 ret += iret;
1327 } else {
1328 addr_to_str((struct sockaddr_storage *)sockaddr, pn, sizeof(pn));
1329 ret = lf_text(dst, pn, size, node);
1330 if (ret == NULL)
1331 return NULL;
1332 }
1333 return ret;
1334}
1335
1336/*
1337 * Write a port to the log
1338 * +X option write in hexadecimal notation, most signifant byte on the left
1339 */
Willy Tarreau26ffa852018-09-05 15:23:10 +02001340char *lf_port(char *dst, const struct sockaddr *sockaddr, size_t size, const struct logformat_node *node)
William Lallemand5f232402012-04-05 18:02:55 +02001341{
1342 char *ret = dst;
1343 int iret;
1344
1345 if (node->options & LOG_OPT_HEXA) {
1346 const unsigned char *port = (const unsigned char *)&((struct sockaddr_in *)sockaddr)->sin_port;
1347 iret = snprintf(dst, size, "%02X%02X", port[0], port[1]);
1348 if (iret < 0 || iret > size)
1349 return NULL;
1350 ret += iret;
1351 } else {
1352 ret = ltoa_o(get_host_port((struct sockaddr_storage *)sockaddr), dst, size);
1353 if (ret == NULL)
1354 return NULL;
1355 }
1356 return ret;
1357}
1358
Dragan Dosen1322d092015-09-22 16:05:32 +02001359/* Re-generate time-based part of the syslog header in RFC3164 format at
1360 * the beginning of logheader once a second and return the pointer to the
1361 * first character after it.
Willy Tarreaub1a2faf2012-03-19 16:51:53 +01001362 */
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001363static char *update_log_hdr(const time_t time)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001364{
Christopher Fauletf8188c62017-06-02 16:20:16 +02001365 static THREAD_LOCAL long tvsec;
Willy Tarreau83061a82018-07-13 11:56:34 +02001366 static THREAD_LOCAL struct buffer host = { };
Christopher Fauletf8188c62017-06-02 16:20:16 +02001367 static THREAD_LOCAL int sep = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001368
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001369 if (unlikely(time != tvsec || logheader_end == NULL)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001370 /* this string is rebuild only once a second */
Willy Tarreaufe944602007-10-25 10:34:16 +02001371 struct tm tm;
Willy Tarreaub1a2faf2012-03-19 16:51:53 +01001372 int hdr_len;
Willy Tarreaufe944602007-10-25 10:34:16 +02001373
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001374 tvsec = time;
Willy Tarreaufe944602007-10-25 10:34:16 +02001375 get_localtime(tvsec, &tm);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001376
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001377 if (unlikely(global.log_send_hostname != host.area)) {
1378 host.area = global.log_send_hostname;
1379 host.data = host.area ? strlen(host.area) : 0;
1380 sep = host.data ? 1 : 0;
Dragan Dosen43885c72015-10-01 13:18:13 +02001381 }
1382
Dragan Dosen59cee972015-09-19 22:09:02 +02001383 hdr_len = snprintf(logheader, global.max_syslog_len,
Dragan Dosen43885c72015-10-01 13:18:13 +02001384 "<<<<>%s %2d %02d:%02d:%02d %.*s%*s",
Willy Tarreaufe944602007-10-25 10:34:16 +02001385 monthname[tm.tm_mon],
Dragan Dosen43885c72015-10-01 13:18:13 +02001386 tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001387 (int)host.data, host.area, sep, "");
Willy Tarreaubaaee002006-06-26 02:48:02 +02001388 /* WARNING: depending upon implementations, snprintf may return
1389 * either -1 or the number of bytes that would be needed to store
1390 * the total message. In both cases, we must adjust it.
1391 */
Willy Tarreau18324f52014-06-27 18:10:07 +02001392 if (hdr_len < 0 || hdr_len > global.max_syslog_len)
1393 hdr_len = global.max_syslog_len;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001394
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001395 logheader_end = logheader + hdr_len;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001396 }
1397
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001398 logheader_end[0] = 0; // ensure we get rid of any previous attempt
Willy Tarreau094af4e2015-01-07 15:03:42 +01001399
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001400 return logheader_end;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001401}
1402
Dragan Dosen1322d092015-09-22 16:05:32 +02001403/* Re-generate time-based part of the syslog header in RFC5424 format at
1404 * the beginning of logheader_rfc5424 once a second and return the pointer
1405 * to the first character after it.
1406 */
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001407static char *update_log_hdr_rfc5424(const time_t time)
Dragan Dosen1322d092015-09-22 16:05:32 +02001408{
Christopher Fauletf8188c62017-06-02 16:20:16 +02001409 static THREAD_LOCAL long tvsec;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001410 const char *gmt_offset;
Dragan Dosen1322d092015-09-22 16:05:32 +02001411
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001412 if (unlikely(time != tvsec || logheader_rfc5424_end == NULL)) {
Dragan Dosen1322d092015-09-22 16:05:32 +02001413 /* this string is rebuild only once a second */
1414 struct tm tm;
1415 int hdr_len;
1416
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001417 tvsec = time;
Dragan Dosen1322d092015-09-22 16:05:32 +02001418 get_localtime(tvsec, &tm);
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001419 gmt_offset = get_gmt_offset(time, &tm);
Dragan Dosen1322d092015-09-22 16:05:32 +02001420
1421 hdr_len = snprintf(logheader_rfc5424, global.max_syslog_len,
Dragan Dosen17def462015-10-09 21:31:43 +02001422 "<<<<>1 %4d-%02d-%02dT%02d:%02d:%02d%.3s:%.2s %s ",
Dragan Dosen1322d092015-09-22 16:05:32 +02001423 tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
Dragan Dosen17def462015-10-09 21:31:43 +02001424 tm.tm_hour, tm.tm_min, tm.tm_sec,
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001425 gmt_offset, gmt_offset+3,
Dragan Dosen43885c72015-10-01 13:18:13 +02001426 global.log_send_hostname ? global.log_send_hostname : hostname);
Dragan Dosen1322d092015-09-22 16:05:32 +02001427 /* WARNING: depending upon implementations, snprintf may return
1428 * either -1 or the number of bytes that would be needed to store
1429 * the total message. In both cases, we must adjust it.
1430 */
1431 if (hdr_len < 0 || hdr_len > global.max_syslog_len)
1432 hdr_len = global.max_syslog_len;
1433
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001434 logheader_rfc5424_end = logheader_rfc5424 + hdr_len;
Dragan Dosen1322d092015-09-22 16:05:32 +02001435 }
1436
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001437 logheader_rfc5424_end[0] = 0; // ensure we get rid of any previous attempt
Dragan Dosen1322d092015-09-22 16:05:32 +02001438
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001439 return logheader_rfc5424_end;
Dragan Dosen1322d092015-09-22 16:05:32 +02001440}
1441
William Lallemand2a4a44f2012-02-06 16:00:33 +01001442/*
Dragan Dosen59cee972015-09-19 22:09:02 +02001443 * This function sends the syslog message using a printf format string. It
1444 * expects an LF-terminated message.
William Lallemand2a4a44f2012-02-06 16:00:33 +01001445 */
1446void send_log(struct proxy *p, int level, const char *format, ...)
1447{
1448 va_list argp;
Willy Tarreaub1a2faf2012-03-19 16:51:53 +01001449 int data_len;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001450
Willy Tarreau8c97ab52015-01-15 16:29:53 +01001451 if (level < 0 || format == NULL || logline == NULL)
William Lallemand2a4a44f2012-02-06 16:00:33 +01001452 return;
1453
William Lallemand2a4a44f2012-02-06 16:00:33 +01001454 va_start(argp, format);
Dragan Dosen59cee972015-09-19 22:09:02 +02001455 data_len = vsnprintf(logline, global.max_syslog_len, format, argp);
Willy Tarreau18324f52014-06-27 18:10:07 +02001456 if (data_len < 0 || data_len > global.max_syslog_len)
1457 data_len = global.max_syslog_len;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001458 va_end(argp);
William Lallemand2a4a44f2012-02-06 16:00:33 +01001459
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001460 __send_log(p, level, logline, data_len, default_rfc5424_sd_log_format, 2);
William Lallemand2a4a44f2012-02-06 16:00:33 +01001461}
1462
1463/*
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001464 * This function sends a syslog message to <logsrv>.
1465 * <pid_str> is the string to be used for the PID of the caller, <pid_size> is length.
1466 * Same thing for <sd> and <sd_size> which are used for the structured-data part
1467 * in RFC5424 formatted syslog messages, and <tag_str> and <tag_size> the syslog tag.
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001468 * It overrides the last byte of the message vector with an LF character.
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001469 * Does not return any error,
William Lallemand2a4a44f2012-02-06 16:00:33 +01001470 */
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001471static inline void __do_send_log(struct logsrv *logsrv, int nblogger, char *pid_str, size_t pid_size,
1472 int level, char *message, size_t size, char *sd, size_t sd_size,
1473 char *tag_str, size_t tag_size)
William Lallemand2a4a44f2012-02-06 16:00:33 +01001474{
Christopher Fauletf8188c62017-06-02 16:20:16 +02001475 static THREAD_LOCAL struct iovec iovec[NB_MSG_IOVEC_ELEMENTS] = { };
1476 static THREAD_LOCAL struct msghdr msghdr = {
1477 //.msg_iov = iovec,
Dragan Dosen609ac2a2015-09-16 18:25:42 +02001478 .msg_iovlen = NB_MSG_IOVEC_ELEMENTS
1479 };
Christopher Fauletf8188c62017-06-02 16:20:16 +02001480 static THREAD_LOCAL int logfdunix = -1; /* syslog to AF_UNIX socket */
1481 static THREAD_LOCAL int logfdinet = -1; /* syslog to AF_INET socket */
1482 static THREAD_LOCAL char *dataptr = NULL;
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001483 time_t time = date.tv_sec;
Dragan Dosen1322d092015-09-22 16:05:32 +02001484 char *hdr, *hdr_ptr;
Dragan Dosen59cee972015-09-19 22:09:02 +02001485 size_t hdr_size;
Willy Tarreau83061a82018-07-13 11:56:34 +02001486 struct buffer *tag = &global.log_tag;
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001487 int fac_level;
1488 int *plogfd;
1489 char *pid_sep1 = "", *pid_sep2 = "";
1490 char logheader_short[3];
1491 int sent;
1492 int maxlen;
1493 int hdr_max = 0;
1494 int tag_max = 0;
1495 int pid_sep1_max = 0;
1496 int pid_sep2_max = 0;
1497 int sd_max = 0;
1498 int max = 0;
Christopher Fauletf8188c62017-06-02 16:20:16 +02001499
1500 msghdr.msg_iov = iovec;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001501
1502 dataptr = message;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001503
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001504 if (logsrv->addr.ss_family == AF_UNSPEC) {
1505 /* the socket's address is a file descriptor */
1506 plogfd = (int *)&((struct sockaddr_in *)&logsrv->addr)->sin_addr.s_addr;
1507 if (unlikely(!((struct sockaddr_in *)&logsrv->addr)->sin_port)) {
1508 /* FD not yet initialized to non-blocking mode.
1509 * DON'T DO IT ON A TERMINAL!
1510 */
1511 if (!isatty(*plogfd))
1512 fcntl(*plogfd, F_SETFL, O_NONBLOCK);
1513 ((struct sockaddr_in *)&logsrv->addr)->sin_port = 1;
Dragan Dosen43885c72015-10-01 13:18:13 +02001514 }
Robert Tsai81ae1952007-12-05 10:47:29 +01001515 }
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001516 else if (logsrv->addr.ss_family == AF_UNIX)
1517 plogfd = &logfdunix;
1518 else
1519 plogfd = &logfdinet;
Robert Tsai81ae1952007-12-05 10:47:29 +01001520
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001521 if (unlikely(*plogfd < 0)) {
1522 /* socket not successfully initialized yet */
1523 if ((*plogfd = socket(logsrv->addr.ss_family, SOCK_DGRAM,
1524 (logsrv->addr.ss_family == AF_UNIX) ? 0 : IPPROTO_UDP)) < 0) {
1525 static char once;
William Lallemand0f99e342011-10-12 17:50:54 +02001526
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001527 if (!once) {
1528 once = 1; /* note: no need for atomic ops here */
1529 ha_alert("socket() failed in logger #%d: %s (errno=%d)\n",
1530 nblogger, strerror(errno), errno);
1531 }
1532 return;
1533 } else {
1534 /* we don't want to receive anything on this socket */
1535 setsockopt(*plogfd, SOL_SOCKET, SO_RCVBUF, &zero, sizeof(zero));
1536 /* does nothing under Linux, maybe needed for others */
1537 shutdown(*plogfd, SHUT_RD);
1538 fcntl(*plogfd, F_SETFD, fcntl(*plogfd, F_GETFD, FD_CLOEXEC) | FD_CLOEXEC);
1539 }
Dragan Dosen43885c72015-10-01 13:18:13 +02001540 }
1541
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001542 switch (logsrv->format) {
1543 case LOG_FORMAT_RFC3164:
1544 hdr = logheader;
1545 hdr_ptr = update_log_hdr(time);
1546 break;
Willy Tarreauc7c7be22014-06-23 18:07:15 +02001547
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001548 case LOG_FORMAT_RFC5424:
1549 hdr = logheader_rfc5424;
1550 hdr_ptr = update_log_hdr_rfc5424(time);
1551 sd_max = sd_size; /* the SD part allowed only in RFC5424 */
1552 break;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001553
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001554 case LOG_FORMAT_SHORT:
1555 /* all fields are known, skip the header generation */
1556 hdr = logheader_short;
1557 hdr[0] = '<';
1558 hdr[1] = '0' + MAX(level, logsrv->minlvl);
1559 hdr[2] = '>';
1560 hdr_ptr = hdr;
1561 hdr_max = 3;
1562 maxlen = logsrv->maxlen - hdr_max;
1563 max = MIN(size, maxlen) - 1;
1564 goto send;
Willy Tarreau204e3f12018-12-15 15:48:48 +01001565
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001566 case LOG_FORMAT_RAW:
1567 /* all fields are known, skip the header generation */
1568 hdr_ptr = hdr = "";
1569 hdr_max = 0;
1570 maxlen = logsrv->maxlen;
1571 max = MIN(size, maxlen) - 1;
1572 goto send;
Willy Tarreauc98aebc2018-03-20 11:17:29 +01001573
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001574 default:
1575 return; /* must never happen */
1576 }
Willy Tarreauc7c7be22014-06-23 18:07:15 +02001577
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001578 hdr_size = hdr_ptr - hdr;
Dragan Dosen1322d092015-09-22 16:05:32 +02001579
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001580 /* For each target, we may have a different facility.
1581 * We can also have a different log level for each message.
1582 * This induces variations in the message header length.
1583 * Since we don't want to recompute it each time, nor copy it every
1584 * time, we only change the facility in the pre-computed header,
1585 * and we change the pointer to the header accordingly.
1586 */
1587 fac_level = (logsrv->facility << 3) + MAX(level, logsrv->minlvl);
1588 hdr_ptr = hdr + 3; /* last digit of the log level */
1589 do {
1590 *hdr_ptr = '0' + fac_level % 10;
1591 fac_level /= 10;
1592 hdr_ptr--;
1593 } while (fac_level && hdr_ptr > hdr);
1594 *hdr_ptr = '<';
Dragan Dosen1322d092015-09-22 16:05:32 +02001595
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001596 hdr_max = hdr_size - (hdr_ptr - hdr);
Willy Tarreaue8746a02018-11-12 08:45:00 +01001597
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001598 /* time-based header */
1599 if (unlikely(hdr_size >= logsrv->maxlen)) {
1600 hdr_max = MIN(hdr_max, logsrv->maxlen) - 1;
1601 sd_max = 0;
1602 goto send;
1603 }
Willy Tarreauc1b06452018-11-12 11:57:56 +01001604
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001605 maxlen = logsrv->maxlen - hdr_max;
Dragan Dosen1322d092015-09-22 16:05:32 +02001606
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001607 /* tag */
1608 tag_max = tag->data;
1609 if (unlikely(tag_max >= maxlen)) {
1610 tag_max = maxlen - 1;
1611 sd_max = 0;
1612 goto send;
1613 }
Dragan Dosen1322d092015-09-22 16:05:32 +02001614
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001615 maxlen -= tag_max;
William Lallemand2a4a44f2012-02-06 16:00:33 +01001616
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001617 /* first pid separator */
1618 pid_sep1_max = log_formats[logsrv->format].pid.sep1.data;
1619 if (unlikely(pid_sep1_max >= maxlen)) {
1620 pid_sep1_max = maxlen - 1;
1621 sd_max = 0;
1622 goto send;
1623 }
Dragan Dosen59cee972015-09-19 22:09:02 +02001624
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001625 pid_sep1 = log_formats[logsrv->format].pid.sep1.area;
1626 maxlen -= pid_sep1_max;
Dragan Dosen59cee972015-09-19 22:09:02 +02001627
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001628 /* pid */
1629 if (unlikely(pid_size >= maxlen)) {
1630 pid_size = maxlen - 1;
1631 sd_max = 0;
1632 goto send;
1633 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02001634
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001635 maxlen -= pid_size;
Dragan Dosen43885c72015-10-01 13:18:13 +02001636
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001637 /* second pid separator */
1638 pid_sep2_max = log_formats[logsrv->format].pid.sep2.data;
1639 if (unlikely(pid_sep2_max >= maxlen)) {
1640 pid_sep2_max = maxlen - 1;
1641 sd_max = 0;
1642 goto send;
1643 }
Dragan Dosen43885c72015-10-01 13:18:13 +02001644
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001645 pid_sep2 = log_formats[logsrv->format].pid.sep2.area;
1646 maxlen -= pid_sep2_max;
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02001647
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001648 /* structured-data */
1649 if (sd_max >= maxlen) {
1650 sd_max = maxlen - 1;
1651 goto send;
1652 }
Dragan Dosen59cee972015-09-19 22:09:02 +02001653
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001654 max = MIN(size, maxlen - sd_max) - 1;
1655send:
1656 iovec[0].iov_base = hdr_ptr;
1657 iovec[0].iov_len = hdr_max;
1658 iovec[1].iov_base = tag_str;
1659 iovec[1].iov_len = tag_size;
1660 iovec[2].iov_base = pid_sep1;
1661 iovec[2].iov_len = pid_sep1_max;
1662 iovec[3].iov_base = pid_str;
1663 iovec[3].iov_len = pid_size;
1664 iovec[4].iov_base = pid_sep2;
1665 iovec[4].iov_len = pid_sep2_max;
1666 iovec[5].iov_base = sd;
1667 iovec[5].iov_len = sd_max;
1668 iovec[6].iov_base = dataptr;
1669 iovec[6].iov_len = max;
1670 iovec[7].iov_base = "\n"; /* insert a \n at the end of the message */
1671 iovec[7].iov_len = 1;
Dragan Dosen43885c72015-10-01 13:18:13 +02001672
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001673 if (logsrv->addr.ss_family == AF_UNSPEC) {
1674 /* the target is a direct file descriptor */
1675 sent = writev(*plogfd, iovec, 8);
1676 }
1677 else {
1678 msghdr.msg_name = (struct sockaddr *)&logsrv->addr;
1679 msghdr.msg_namelen = get_addr_len(&logsrv->addr);
Dragan Dosen43885c72015-10-01 13:18:13 +02001680
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001681 sent = sendmsg(*plogfd, &msghdr, MSG_DONTWAIT | MSG_NOSIGNAL);
1682 }
Dragan Dosen43885c72015-10-01 13:18:13 +02001683
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001684 if (sent < 0) {
1685 static char once;
Dragan Dosen43885c72015-10-01 13:18:13 +02001686
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001687 if (errno == EAGAIN)
1688 _HA_ATOMIC_ADD(&dropped_logs, 1);
1689 else if (!once) {
1690 once = 1; /* note: no need for atomic ops here */
1691 ha_alert("sendmsg()/writev() failed in logger #%d: %s (errno=%d)\n",
1692 nblogger, strerror(errno), errno);
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001693 }
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001694 }
1695}
Dragan Dosen59cee972015-09-19 22:09:02 +02001696
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001697/*
1698 * This function sends a syslog message.
1699 * It doesn't care about errors nor does it report them.
1700 * The arguments <sd> and <sd_size> are used for the structured-data part
1701 * in RFC5424 formatted syslog messages.
1702 */
1703void __send_log(struct proxy *p, int level, char *message, size_t size, char *sd, size_t sd_size)
1704{
1705 struct list *logsrvs = NULL;
1706 struct logsrv *logsrv;
1707 int nblogger;
1708 static THREAD_LOCAL int curr_pid;
1709 static THREAD_LOCAL char pidstr[100];
1710 static THREAD_LOCAL struct buffer pid;
1711 struct buffer *tag = &global.log_tag;
Dragan Dosen609ac2a2015-09-16 18:25:42 +02001712
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001713 if (p == NULL) {
1714 if (!LIST_ISEMPTY(&global.logsrvs)) {
1715 logsrvs = &global.logsrvs;
Willy Tarreau5a32ecc2018-11-12 07:34:59 +01001716 }
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001717 } else {
1718 if (!LIST_ISEMPTY(&p->logsrvs)) {
1719 logsrvs = &p->logsrvs;
Willy Tarreau5a32ecc2018-11-12 07:34:59 +01001720 }
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001721 if (p->log_tag.area) {
1722 tag = &p->log_tag;
1723 }
1724 }
Willy Tarreau18324f52014-06-27 18:10:07 +02001725
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001726 if (!logsrvs)
1727 return;
Willy Tarreauc98aebc2018-03-20 11:17:29 +01001728
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001729 if (unlikely(curr_pid != getpid())) {
1730 curr_pid = getpid();
1731 ltoa_o(curr_pid, pidstr, sizeof(pidstr));
1732 chunk_initstr(&pid, pidstr);
1733 }
1734
1735 /* Send log messages to syslog server. */
1736 nblogger = 0;
1737 list_for_each_entry(logsrv, logsrvs, list) {
Frédéric Lécailled803e472019-04-25 07:42:09 +02001738 static THREAD_LOCAL int in_range = 1;
1739
Frédéric Lécaille0bad8402019-04-10 08:22:17 +02001740 /* we can filter the level of the messages that are sent to each logger */
1741 if (level > logsrv->level)
1742 continue;
1743
Frédéric Lécailled803e472019-04-25 07:42:09 +02001744 if (logsrv->lb.smp_rgs) {
1745 struct smp_log_range *curr_rg;
1746
1747 HA_SPIN_LOCK(LOGSRV_LOCK, &logsrv->lock);
1748 curr_rg = &logsrv->lb.smp_rgs[logsrv->lb.curr_rg];
1749 in_range = in_smp_log_range(curr_rg, logsrv->lb.curr_idx);
1750 if (in_range) {
1751 /* Let's consume this range. */
1752 curr_rg->curr_idx = (curr_rg->curr_idx + 1) % curr_rg->sz;
1753 if (!curr_rg->curr_idx) {
1754 /* If consumed, let's select the next range. */
1755 logsrv->lb.curr_rg = (logsrv->lb.curr_rg + 1) % logsrv->lb.smp_rgs_sz;
1756 }
1757 }
1758 logsrv->lb.curr_idx = (logsrv->lb.curr_idx + 1) % logsrv->lb.smp_sz;
1759 HA_SPIN_UNLOCK(LOGSRV_LOCK, &logsrv->lock);
1760 }
1761 if (in_range)
1762 __do_send_log(logsrv, ++nblogger, pid.area, pid.data, level,
1763 message, size, sd, sd_size, tag->area, tag->data);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001764 }
1765}
1766
William Lallemandbddd4fd2012-02-27 11:23:10 +01001767extern fd_set hdr_encode_map[];
1768extern fd_set url_encode_map[];
Thierry FOURNIERd048d8b2014-03-13 16:46:18 +01001769extern fd_set http_encode_map[];
William Lallemandbddd4fd2012-02-27 11:23:10 +01001770
Willy Tarreaubaaee002006-06-26 02:48:02 +02001771
Willy Tarreauc89ccb62012-04-05 21:18:22 +02001772const 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 +01001773const char sess_set_cookie[8] = "NPDIRU67"; /* No set-cookie, Set-cookie found and left unchanged (passive),
1774 Set-cookie Deleted, Set-Cookie Inserted, Set-cookie Rewritten,
1775 Set-cookie Updated, unknown, unknown */
1776
William Lallemand1d705562012-03-12 12:46:41 +01001777/*
1778 * try to write a character if there is enough space, or goto out
1779 */
William Lallemandbddd4fd2012-02-27 11:23:10 +01001780#define LOGCHAR(x) do { \
William Lallemand1d705562012-03-12 12:46:41 +01001781 if (tmplog < dst + maxsize - 1) { \
William Lallemandbddd4fd2012-02-27 11:23:10 +01001782 *(tmplog++) = (x); \
1783 } else { \
1784 goto out; \
1785 } \
1786 } while(0)
1787
Dragan Dosen835b9212016-02-12 13:23:03 +01001788
Willy Tarreaub6b3df32018-11-26 16:31:20 +01001789/* Initializes some log data at boot */
1790static void init_log()
Dragan Dosen835b9212016-02-12 13:23:03 +01001791{
1792 char *tmp;
Willy Tarreaue10cd482018-09-10 18:16:53 +02001793 int i;
Dragan Dosen835b9212016-02-12 13:23:03 +01001794
1795 /* Initialize the escape map for the RFC5424 structured-data : '"\]'
1796 * inside PARAM-VALUE should be escaped with '\' as prefix.
1797 * See https://tools.ietf.org/html/rfc5424#section-6.3.3 for more
1798 * details.
1799 */
1800 memset(rfc5424_escape_map, 0, sizeof(rfc5424_escape_map));
1801
1802 tmp = "\"\\]";
1803 while (*tmp) {
1804 FD_SET(*tmp, rfc5424_escape_map);
1805 tmp++;
1806 }
Willy Tarreaue10cd482018-09-10 18:16:53 +02001807
1808 /* initialize the log header encoding map : '{|}"#' should be encoded with
1809 * '#' as prefix, as well as non-printable characters ( <32 or >= 127 ).
1810 * URL encoding only requires '"', '#' to be encoded as well as non-
1811 * printable characters above.
1812 */
1813 memset(hdr_encode_map, 0, sizeof(hdr_encode_map));
1814 memset(url_encode_map, 0, sizeof(url_encode_map));
1815 for (i = 0; i < 32; i++) {
1816 FD_SET(i, hdr_encode_map);
1817 FD_SET(i, url_encode_map);
1818 }
1819 for (i = 127; i < 256; i++) {
1820 FD_SET(i, hdr_encode_map);
1821 FD_SET(i, url_encode_map);
1822 }
1823
1824 tmp = "\"#{|}";
1825 while (*tmp) {
1826 FD_SET(*tmp, hdr_encode_map);
1827 tmp++;
1828 }
1829
1830 tmp = "\"#";
1831 while (*tmp) {
1832 FD_SET(*tmp, url_encode_map);
1833 tmp++;
1834 }
1835
1836 /* initialize the http header encoding map. The draft httpbis define the
1837 * header content as:
1838 *
1839 * HTTP-message = start-line
1840 * *( header-field CRLF )
1841 * CRLF
1842 * [ message-body ]
1843 * header-field = field-name ":" OWS field-value OWS
1844 * field-value = *( field-content / obs-fold )
1845 * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
1846 * obs-fold = CRLF 1*( SP / HTAB )
1847 * field-vchar = VCHAR / obs-text
1848 * VCHAR = %x21-7E
1849 * obs-text = %x80-FF
1850 *
1851 * All the chars are encoded except "VCHAR", "obs-text", SP and HTAB.
1852 * The encoded chars are form 0x00 to 0x08, 0x0a to 0x1f and 0x7f. The
Joseph Herlant85b40592018-11-15 12:10:04 -08001853 * "obs-fold" is voluntarily forgotten because haproxy remove this.
Willy Tarreaue10cd482018-09-10 18:16:53 +02001854 */
1855 memset(http_encode_map, 0, sizeof(http_encode_map));
1856 for (i = 0x00; i <= 0x08; i++)
1857 FD_SET(i, http_encode_map);
1858 for (i = 0x0a; i <= 0x1f; i++)
1859 FD_SET(i, http_encode_map);
1860 FD_SET(0x7f, http_encode_map);
Dragan Dosen835b9212016-02-12 13:23:03 +01001861}
William Lallemand1d705562012-03-12 12:46:41 +01001862
Willy Tarreaub6b3df32018-11-26 16:31:20 +01001863INITCALL0(STG_PREPARE, init_log);
1864
Christopher Fauletcd7879a2017-10-27 13:53:47 +02001865static int init_log_buffers_per_thread()
1866{
1867 return init_log_buffers();
1868}
1869
1870static void deinit_log_buffers_per_thread()
1871{
1872 deinit_log_buffers();
1873}
1874
Christopher Faulet0132d062017-07-26 15:33:35 +02001875/* Initialize log buffers used for syslog messages */
1876int init_log_buffers()
1877{
1878 logheader = my_realloc2(logheader, global.max_syslog_len + 1);
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001879 logheader_end = NULL;
Christopher Faulet0132d062017-07-26 15:33:35 +02001880 logheader_rfc5424 = my_realloc2(logheader_rfc5424, global.max_syslog_len + 1);
Willy Tarreau55e2f5a2019-05-05 10:11:39 +02001881 logheader_rfc5424_end = NULL;
Christopher Faulet0132d062017-07-26 15:33:35 +02001882 logline = my_realloc2(logline, global.max_syslog_len + 1);
1883 logline_rfc5424 = my_realloc2(logline_rfc5424, global.max_syslog_len + 1);
1884 if (!logheader || !logline_rfc5424 || !logline || !logline_rfc5424)
1885 return 0;
1886 return 1;
1887}
1888
1889/* Deinitialize log buffers used for syslog messages */
1890void deinit_log_buffers()
1891{
Olivier Houchard7c497112019-03-07 14:19:24 +01001892 void *tmp_startup_logs;
1893
Christopher Faulet0132d062017-07-26 15:33:35 +02001894 free(logheader);
1895 free(logheader_rfc5424);
1896 free(logline);
1897 free(logline_rfc5424);
Olivier Houchardd2ee3e72019-03-08 18:53:21 +01001898 tmp_startup_logs = _HA_ATOMIC_XCHG(&startup_logs, NULL);
Olivier Houchard7c497112019-03-07 14:19:24 +01001899 free(tmp_startup_logs);
1900
Christopher Faulet0132d062017-07-26 15:33:35 +02001901 logheader = NULL;
1902 logheader_rfc5424 = NULL;
1903 logline = NULL;
1904 logline_rfc5424 = NULL;
Christopher Fauletd4696382017-10-24 11:44:05 +02001905 startup_logs = NULL;
Christopher Faulet0132d062017-07-26 15:33:35 +02001906}
1907
Willy Tarreaudf974472012-12-28 02:44:01 +01001908/* Builds a log line in <dst> based on <list_format>, and stops before reaching
1909 * <maxsize> characters. Returns the size of the output string in characters,
1910 * not counting the trailing zero which is always added if the resulting size
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001911 * is not zero. It requires a valid session and optionally a stream. If the
1912 * stream is NULL, default values will be assumed for the stream part.
Willy Tarreaudf974472012-12-28 02:44:01 +01001913 */
Willy Tarreau43c538e2018-09-05 14:58:15 +02001914int 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 +02001915{
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02001916 struct proxy *fe = sess->fe;
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001917 struct proxy *be;
1918 struct http_txn *txn;
1919 const struct strm_logs *logs;
1920 const struct connection *be_conn;
1921 unsigned int s_flags;
1922 unsigned int uniq_id;
Willy Tarreau83061a82018-07-13 11:56:34 +02001923 struct buffer chunk;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001924 char *uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00001925 char *spc;
Andrew Hayworthe63ac872015-07-31 16:14:16 +00001926 char *qmark;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00001927 char *end;
Willy Tarreaufe944602007-10-25 10:34:16 +02001928 struct tm tm;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001929 int t_request;
1930 int hdr;
1931 int last_isspace = 1;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00001932 int nspaces = 0;
Willy Tarreaub1a2faf2012-03-19 16:51:53 +01001933 char *tmplog;
William Lallemand1d705562012-03-12 12:46:41 +01001934 char *ret;
1935 int iret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001936 struct logformat_node *tmp;
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02001937 struct timeval tv;
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001938 struct strm_logs tmp_strm_log;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001939
William Lallemandbddd4fd2012-02-27 11:23:10 +01001940 /* FIXME: let's limit ourselves to frontend logging for now. */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001941
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001942 if (likely(s)) {
1943 be = s->be;
1944 txn = s->txn;
1945 be_conn = cs_conn(objt_cs(s->si[1].end));
1946 s_flags = s->flags;
1947 uniq_id = s->uniq_id;
1948 logs = &s->logs;
1949 } else {
1950 /* we have no stream so we first need to initialize a few
1951 * things that are needed later. We do increment the request
1952 * ID so that it's uniquely assigned to this request just as
1953 * if the request had reached the point of being processed.
1954 * A request error is reported as it's the only element we have
1955 * here and which justifies emitting such a log.
1956 */
1957 be = fe;
1958 txn = NULL;
1959 be_conn = NULL;
1960 s_flags = SF_ERR_PRXCOND | SF_FINST_R;
Olivier Houchardd2ee3e72019-03-08 18:53:21 +01001961 uniq_id = _HA_ATOMIC_XADD(&global.req_count, 1);
Willy Tarreau09bb27c2018-09-05 16:55:15 +02001962
1963 /* prepare a valid log structure */
1964 tmp_strm_log.tv_accept = sess->tv_accept;
1965 tmp_strm_log.accept_date = sess->accept_date;
1966 tmp_strm_log.t_handshake = sess->t_handshake;
1967 tmp_strm_log.t_idle = tv_ms_elapsed(&sess->tv_accept, &now) - sess->t_handshake;
1968 tv_zero(&tmp_strm_log.tv_request);
1969 tmp_strm_log.t_queue = -1;
1970 tmp_strm_log.t_connect = -1;
1971 tmp_strm_log.t_data = -1;
1972 tmp_strm_log.t_close = tv_ms_elapsed(&sess->tv_accept, &now);
1973 tmp_strm_log.bytes_in = 0;
1974 tmp_strm_log.bytes_out = 0;
1975 tmp_strm_log.prx_queue_pos = 0;
1976 tmp_strm_log.srv_queue_pos = 0;
1977
1978 logs = &tmp_strm_log;
1979 }
1980
William Lallemandbddd4fd2012-02-27 11:23:10 +01001981 t_request = -1;
Willy Tarreau372ac5a2018-09-05 15:16:23 +02001982 if (tv_isge(&logs->tv_request, &logs->tv_accept))
1983 t_request = tv_ms_elapsed(&logs->tv_accept, &logs->tv_request);
William Lallemandbddd4fd2012-02-27 11:23:10 +01001984
William Lallemand1d705562012-03-12 12:46:41 +01001985 tmplog = dst;
Willy Tarreauc9bd0cc2009-05-10 11:57:02 +02001986
William Lallemandbddd4fd2012-02-27 11:23:10 +01001987 /* fill logbuffer */
William Lallemand1d705562012-03-12 12:46:41 +01001988 if (LIST_ISEMPTY(list_format))
1989 return 0;
William Lallemandbddd4fd2012-02-27 11:23:10 +01001990
William Lallemand1d705562012-03-12 12:46:41 +01001991 list_for_each_entry(tmp, list_format, list) {
Willy Tarreaub363a1f2013-10-01 10:45:07 +02001992 struct connection *conn;
Willy Tarreau4f653562012-10-12 19:48:16 +02001993 const char *src = NULL;
Willy Tarreauc8368452012-12-21 00:09:23 +01001994 struct sample *key;
Willy Tarreau83061a82018-07-13 11:56:34 +02001995 const struct buffer empty = { };
William Lallemandbddd4fd2012-02-27 11:23:10 +01001996
Willy Tarreauc8368452012-12-21 00:09:23 +01001997 switch (tmp->type) {
William Lallemand1d705562012-03-12 12:46:41 +01001998 case LOG_FMT_SEPARATOR:
William Lallemandbddd4fd2012-02-27 11:23:10 +01001999 if (!last_isspace) {
2000 LOGCHAR(' ');
2001 last_isspace = 1;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002002 }
2003 break;
2004
William Lallemand1d705562012-03-12 12:46:41 +01002005 case LOG_FMT_TEXT: // text
William Lallemandbddd4fd2012-02-27 11:23:10 +01002006 src = tmp->arg;
William Lallemand5f232402012-04-05 18:02:55 +02002007 iret = strlcpy2(tmplog, src, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002008 if (iret == 0)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002009 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002010 tmplog += iret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002011 last_isspace = 0;
2012 break;
2013
Willy Tarreauc8368452012-12-21 00:09:23 +01002014 case LOG_FMT_EXPR: // sample expression, may be request or response
2015 key = NULL;
Olivier Houchardf90db442018-12-15 14:00:06 +01002016 if (tmp->options & LOG_OPT_REQ_CAP && s)
Adis Nezirovic79beb242015-07-06 15:41:02 +02002017 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 +01002018 if (!key && (tmp->options & LOG_OPT_RES_CAP) && s)
Adis Nezirovic79beb242015-07-06 15:41:02 +02002019 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 +01002020 if (tmp->options & LOG_OPT_HTTP)
Dragan Dosen835b9212016-02-12 13:23:03 +01002021 ret = lf_encode_chunk(tmplog, dst + maxsize,
2022 '%', http_encode_map, key ? &key->data.u.str : &empty, tmp);
Thierry FOURNIERd048d8b2014-03-13 16:46:18 +01002023 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002024 ret = lf_text_len(tmplog,
2025 key ? key->data.u.str.area : NULL,
2026 key ? key->data.u.str.data : 0,
2027 dst + maxsize - tmplog,
2028 tmp);
Willy Tarreauc8368452012-12-21 00:09:23 +01002029 if (ret == 0)
2030 goto out;
2031 tmplog = ret;
2032 last_isspace = 0;
2033 break;
2034
Willy Tarreau2beef582012-12-20 17:22:52 +01002035 case LOG_FMT_CLIENTIP: // %ci
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002036 conn = objt_conn(sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002037 if (conn)
2038 ret = lf_ip(tmplog, (struct sockaddr *)&conn->addr.from, dst + maxsize - tmplog, tmp);
2039 else
2040 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002041 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002042 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002043 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002044 last_isspace = 0;
2045 break;
2046
Willy Tarreau2beef582012-12-20 17:22:52 +01002047 case LOG_FMT_CLIENTPORT: // %cp
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002048 conn = objt_conn(sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002049 if (conn) {
2050 if (conn->addr.from.ss_family == AF_UNIX) {
Willy Tarreaufb0afa72015-04-03 14:46:27 +02002051 ret = ltoa_o(sess->listener->luid, tmplog, dst + maxsize - tmplog);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002052 } else {
2053 ret = lf_port(tmplog, (struct sockaddr *)&conn->addr.from,
2054 dst + maxsize - tmplog, tmp);
2055 }
William Lallemand5f232402012-04-05 18:02:55 +02002056 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002057 else
2058 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2059
William Lallemand5f232402012-04-05 18:02:55 +02002060 if (ret == NULL)
2061 goto out;
2062 tmplog = ret;
2063 last_isspace = 0;
2064 break;
2065
Willy Tarreau2beef582012-12-20 17:22:52 +01002066 case LOG_FMT_FRONTENDIP: // %fi
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002067 conn = objt_conn(sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002068 if (conn) {
2069 conn_get_to_addr(conn);
2070 ret = lf_ip(tmplog, (struct sockaddr *)&conn->addr.to, dst + maxsize - tmplog, tmp);
2071 }
2072 else
2073 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2074
William Lallemand1d705562012-03-12 12:46:41 +01002075 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002076 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002077 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002078 last_isspace = 0;
2079 break;
2080
Willy Tarreau2beef582012-12-20 17:22:52 +01002081 case LOG_FMT_FRONTENDPORT: // %fp
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002082 conn = objt_conn(sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002083 if (conn) {
2084 conn_get_to_addr(conn);
2085 if (conn->addr.to.ss_family == AF_UNIX)
Willy Tarreaufb0afa72015-04-03 14:46:27 +02002086 ret = ltoa_o(sess->listener->luid, tmplog, dst + maxsize - tmplog);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002087 else
2088 ret = lf_port(tmplog, (struct sockaddr *)&conn->addr.to, dst + maxsize - tmplog, tmp);
William Lallemand5f232402012-04-05 18:02:55 +02002089 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002090 else
2091 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2092
William Lallemand5f232402012-04-05 18:02:55 +02002093 if (ret == NULL)
2094 goto out;
2095 tmplog = ret;
2096 last_isspace = 0;
2097 break;
2098
Willy Tarreau2beef582012-12-20 17:22:52 +01002099 case LOG_FMT_BACKENDIP: // %bi
Willy Tarreau2393c5b2018-09-05 15:24:56 +02002100 if (be_conn)
2101 ret = lf_ip(tmplog, (const struct sockaddr *)&be_conn->addr.from, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002102 else
2103 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2104
William Lallemand1d705562012-03-12 12:46:41 +01002105 if (ret == NULL)
William Lallemandb7ff6a32012-03-02 14:35:21 +01002106 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002107 tmplog = ret;
William Lallemandb7ff6a32012-03-02 14:35:21 +01002108 last_isspace = 0;
2109 break;
2110
Willy Tarreau2beef582012-12-20 17:22:52 +01002111 case LOG_FMT_BACKENDPORT: // %bp
Willy Tarreau2393c5b2018-09-05 15:24:56 +02002112 if (be_conn)
2113 ret = lf_port(tmplog, (struct sockaddr *)&be_conn->addr.from, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002114 else
2115 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2116
William Lallemand5f232402012-04-05 18:02:55 +02002117 if (ret == NULL)
2118 goto out;
2119 tmplog = ret;
2120 last_isspace = 0;
2121 break;
2122
Willy Tarreau2beef582012-12-20 17:22:52 +01002123 case LOG_FMT_SERVERIP: // %si
Willy Tarreau2393c5b2018-09-05 15:24:56 +02002124 if (be_conn)
2125 ret = lf_ip(tmplog, (struct sockaddr *)&be_conn->addr.to, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002126 else
2127 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2128
William Lallemand5f232402012-04-05 18:02:55 +02002129 if (ret == NULL)
2130 goto out;
2131 tmplog = ret;
2132 last_isspace = 0;
2133 break;
2134
Willy Tarreau2beef582012-12-20 17:22:52 +01002135 case LOG_FMT_SERVERPORT: // %sp
Willy Tarreau2393c5b2018-09-05 15:24:56 +02002136 if (be_conn)
2137 ret = lf_port(tmplog, (struct sockaddr *)&be_conn->addr.to, dst + maxsize - tmplog, tmp);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002138 else
2139 ret = lf_text_len(tmplog, NULL, 0, dst + maxsize - tmplog, tmp);
2140
William Lallemand1d705562012-03-12 12:46:41 +01002141 if (ret == NULL)
William Lallemandb7ff6a32012-03-02 14:35:21 +01002142 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002143 tmplog = ret;
William Lallemandb7ff6a32012-03-02 14:35:21 +01002144 last_isspace = 0;
2145 break;
2146
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002147 case LOG_FMT_DATE: // %t = accept date
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002148 get_localtime(logs->accept_date.tv_sec, &tm);
2149 ret = date2str_log(tmplog, &tm, &logs->accept_date, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002150 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002151 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002152 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002153 last_isspace = 0;
2154 break;
2155
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002156 case LOG_FMT_tr: // %tr = start of request date
2157 /* Note that the timers are valid if we get here */
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002158 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 +02002159 get_localtime(tv.tv_sec, &tm);
2160 ret = date2str_log(tmplog, &tm, &tv, dst + maxsize - tmplog);
2161 if (ret == NULL)
2162 goto out;
2163 tmplog = ret;
2164 last_isspace = 0;
2165 break;
2166
2167 case LOG_FMT_DATEGMT: // %T = accept date, GMT
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002168 get_gmtime(logs->accept_date.tv_sec, &tm);
William Lallemand5f232402012-04-05 18:02:55 +02002169 ret = gmt2str_log(tmplog, &tm, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002170 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002171 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002172 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002173 last_isspace = 0;
2174 break;
2175
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002176 case LOG_FMT_trg: // %trg = start of request date, GMT
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002177 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 +02002178 get_gmtime(tv.tv_sec, &tm);
2179 ret = gmt2str_log(tmplog, &tm, dst + maxsize - tmplog);
2180 if (ret == NULL)
2181 goto out;
2182 tmplog = ret;
2183 last_isspace = 0;
2184 break;
2185
2186 case LOG_FMT_DATELOCAL: // %Tl = accept date, local
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002187 get_localtime(logs->accept_date.tv_sec, &tm);
2188 ret = localdate2str_log(tmplog, logs->accept_date.tv_sec, &tm, dst + maxsize - tmplog);
Yuxans Yao4e25b012012-10-19 10:36:09 +08002189 if (ret == NULL)
2190 goto out;
2191 tmplog = ret;
2192 last_isspace = 0;
2193 break;
2194
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002195 case LOG_FMT_trl: // %trl = start of request date, local
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002196 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 +02002197 get_localtime(tv.tv_sec, &tm);
2198 ret = localdate2str_log(tmplog, tv.tv_sec, &tm, dst + maxsize - tmplog);
2199 if (ret == NULL)
2200 goto out;
2201 tmplog = ret;
2202 last_isspace = 0;
2203 break;
2204
William Lallemand5f232402012-04-05 18:02:55 +02002205 case LOG_FMT_TS: // %Ts
William Lallemand5f232402012-04-05 18:02:55 +02002206 if (tmp->options & LOG_OPT_HEXA) {
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002207 iret = snprintf(tmplog, dst + maxsize - tmplog, "%04X", (unsigned int)logs->accept_date.tv_sec);
William Lallemand5f232402012-04-05 18:02:55 +02002208 if (iret < 0 || iret > dst + maxsize - tmplog)
2209 goto out;
2210 last_isspace = 0;
2211 tmplog += iret;
2212 } else {
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002213 ret = ltoa_o(logs->accept_date.tv_sec, tmplog, dst + maxsize - tmplog);
William Lallemand5f232402012-04-05 18:02:55 +02002214 if (ret == NULL)
2215 goto out;
2216 tmplog = ret;
2217 last_isspace = 0;
2218 }
2219 break;
2220
William Lallemand1d705562012-03-12 12:46:41 +01002221 case LOG_FMT_MS: // %ms
William Lallemand5f232402012-04-05 18:02:55 +02002222 if (tmp->options & LOG_OPT_HEXA) {
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002223 iret = snprintf(tmplog, dst + maxsize - tmplog, "%02X",(unsigned int)logs->accept_date.tv_usec/1000);
William Lallemand5f232402012-04-05 18:02:55 +02002224 if (iret < 0 || iret > dst + maxsize - tmplog)
2225 goto out;
2226 last_isspace = 0;
2227 tmplog += iret;
2228 } else {
2229 if ((dst + maxsize - tmplog) < 4)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002230 goto out;
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002231 ret = utoa_pad((unsigned int)logs->accept_date.tv_usec/1000,
Willy Tarreau9e60cd82013-01-24 01:18:16 +01002232 tmplog, 4);
2233 if (ret == NULL)
William Lallemand51b5dca2012-03-26 17:52:55 +02002234 goto out;
Willy Tarreau9e60cd82013-01-24 01:18:16 +01002235 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002236 last_isspace = 0;
William Lallemand5f232402012-04-05 18:02:55 +02002237 }
2238 break;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002239
William Lallemand1d705562012-03-12 12:46:41 +01002240 case LOG_FMT_FRONTEND: // %f
William Lallemandbddd4fd2012-02-27 11:23:10 +01002241 src = fe->id;
William Lallemand5f232402012-04-05 18:02:55 +02002242 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002243 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002244 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002245 tmplog = ret;
William Lallemand51b5dca2012-03-26 17:52:55 +02002246 last_isspace = 0;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002247 break;
2248
Willy Tarreau773d65f2012-10-12 14:56:11 +02002249 case LOG_FMT_FRONTEND_XPRT: // %ft
2250 src = fe->id;
2251 if (tmp->options & LOG_OPT_QUOTE)
2252 LOGCHAR('"');
2253 iret = strlcpy2(tmplog, src, dst + maxsize - tmplog);
2254 if (iret == 0)
2255 goto out;
2256 tmplog += iret;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01002257 if (sess->listener->bind_conf->xprt == xprt_get(XPRT_SSL))
Willy Tarreau773d65f2012-10-12 14:56:11 +02002258 LOGCHAR('~');
Willy Tarreau773d65f2012-10-12 14:56:11 +02002259 if (tmp->options & LOG_OPT_QUOTE)
2260 LOGCHAR('"');
2261 last_isspace = 0;
2262 break;
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02002263#ifdef USE_OPENSSL
2264 case LOG_FMT_SSL_CIPHER: // %sslc
2265 src = NULL;
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002266 conn = objt_conn(sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002267 if (conn) {
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02002268 src = ssl_sock_get_cipher_name(conn);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002269 }
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02002270 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
2271 if (ret == NULL)
2272 goto out;
2273 tmplog = ret;
2274 last_isspace = 0;
2275 break;
Willy Tarreau773d65f2012-10-12 14:56:11 +02002276
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02002277 case LOG_FMT_SSL_VERSION: // %sslv
2278 src = NULL;
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02002279 conn = objt_conn(sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002280 if (conn) {
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02002281 src = ssl_sock_get_proto_version(conn);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002282 }
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02002283 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
2284 if (ret == NULL)
2285 goto out;
2286 tmplog = ret;
2287 last_isspace = 0;
2288 break;
2289#endif
William Lallemand1d705562012-03-12 12:46:41 +01002290 case LOG_FMT_BACKEND: // %b
William Lallemandbddd4fd2012-02-27 11:23:10 +01002291 src = be->id;
William Lallemand5f232402012-04-05 18:02:55 +02002292 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002293 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002294 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002295 tmplog = ret;
William Lallemand51b5dca2012-03-26 17:52:55 +02002296 last_isspace = 0;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002297 break;
2298
William Lallemand1d705562012-03-12 12:46:41 +01002299 case LOG_FMT_SERVER: // %s
Willy Tarreaue1809df2018-09-05 15:30:16 +02002300 switch (obj_type(s ? s->target : NULL)) {
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002301 case OBJ_TYPE_SERVER:
Willy Tarreau1aaf3242018-09-20 11:13:58 +02002302 src = __objt_server(s->target)->id;
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002303 break;
2304 case OBJ_TYPE_APPLET:
Willy Tarreau1aaf3242018-09-20 11:13:58 +02002305 src = __objt_applet(s->target)->name;
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002306 break;
2307 default:
2308 src = "<NOSRV>";
2309 break;
2310 }
William Lallemand5f232402012-04-05 18:02:55 +02002311 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002312 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002313 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002314 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002315 last_isspace = 0;
2316 break;
2317
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002318 case LOG_FMT_Th: // %Th = handshake time
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002319 ret = ltoa_o(logs->t_handshake, tmplog, dst + maxsize - tmplog);
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002320 if (ret == NULL)
2321 goto out;
2322 tmplog = ret;
2323 last_isspace = 0;
2324 break;
2325
2326 case LOG_FMT_Ti: // %Ti = HTTP idle time
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002327 ret = ltoa_o(logs->t_idle, tmplog, dst + maxsize - tmplog);
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002328 if (ret == NULL)
2329 goto out;
2330 tmplog = ret;
2331 last_isspace = 0;
2332 break;
2333
2334 case LOG_FMT_TR: // %TR = HTTP request time
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002335 ret = ltoa_o((t_request >= 0) ? t_request - logs->t_idle - logs->t_handshake : -1,
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002336 tmplog, dst + maxsize - tmplog);
2337 if (ret == NULL)
2338 goto out;
2339 tmplog = ret;
2340 last_isspace = 0;
2341 break;
2342
2343 case LOG_FMT_TQ: // %Tq = Th + Ti + TR
William Lallemand5f232402012-04-05 18:02:55 +02002344 ret = ltoa_o(t_request, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002345 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002346 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002347 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002348 last_isspace = 0;
2349 break;
2350
William Lallemand1d705562012-03-12 12:46:41 +01002351 case LOG_FMT_TW: // %Tw
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002352 ret = ltoa_o((logs->t_queue >= 0) ? logs->t_queue - t_request : -1,
William Lallemand5f232402012-04-05 18:02:55 +02002353 tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002354 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002355 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002356 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002357 last_isspace = 0;
2358 break;
2359
William Lallemand1d705562012-03-12 12:46:41 +01002360 case LOG_FMT_TC: // %Tc
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002361 ret = ltoa_o((logs->t_connect >= 0) ? logs->t_connect - logs->t_queue : -1,
William Lallemand5f232402012-04-05 18:02:55 +02002362 tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002363 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002364 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002365 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002366 last_isspace = 0;
2367 break;
2368
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002369 case LOG_FMT_Tr: // %Tr
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002370 ret = ltoa_o((logs->t_data >= 0) ? logs->t_data - logs->t_connect : -1,
William Lallemand5f232402012-04-05 18:02:55 +02002371 tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002372 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002373 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002374 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002375 last_isspace = 0;
2376 break;
2377
Willy Tarreau27b639d2016-05-17 17:55:27 +02002378 case LOG_FMT_TD: // %Td
Willy Tarreaua21c0e62018-09-05 15:07:15 +02002379 if (be->mode == PR_MODE_HTTP)
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002380 ret = ltoa_o((logs->t_data >= 0) ? logs->t_close - logs->t_data : -1,
Willy Tarreau27b639d2016-05-17 17:55:27 +02002381 tmplog, dst + maxsize - tmplog);
2382 else
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002383 ret = ltoa_o((logs->t_connect >= 0) ? logs->t_close - logs->t_connect : -1,
Willy Tarreau27b639d2016-05-17 17:55:27 +02002384 tmplog, dst + maxsize - tmplog);
2385 if (ret == NULL)
2386 goto out;
2387 tmplog = ret;
2388 last_isspace = 0;
2389 break;
2390
Thierry FOURNIER / OZON.IO4cac3592016-07-28 17:19:45 +02002391 case LOG_FMT_Ta: // %Ta = active time = Tt - Th - Ti
2392 if (!(fe->to_log & LW_BYTES))
2393 LOGCHAR('+');
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002394 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 +02002395 tmplog, dst + maxsize - tmplog);
2396 if (ret == NULL)
2397 goto out;
2398 tmplog = ret;
2399 last_isspace = 0;
2400 break;
2401
2402 case LOG_FMT_TT: // %Tt = total time
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002403 if (!(fe->to_log & LW_BYTES))
William Lallemand1d705562012-03-12 12:46:41 +01002404 LOGCHAR('+');
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002405 ret = ltoa_o(logs->t_close, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002406 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002407 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002408 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002409 last_isspace = 0;
2410 break;
2411
Willy Tarreau2beef582012-12-20 17:22:52 +01002412 case LOG_FMT_STATUS: // %ST
Willy Tarreau57bc8912016-04-25 17:09:40 +02002413 ret = ltoa_o(txn ? txn->status : 0, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002414 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002415 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002416 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002417 last_isspace = 0;
2418 break;
2419
William Lallemand1d705562012-03-12 12:46:41 +01002420 case LOG_FMT_BYTES: // %B
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002421 if (!(fe->to_log & LW_BYTES))
William Lallemand1d705562012-03-12 12:46:41 +01002422 LOGCHAR('+');
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002423 ret = lltoa(logs->bytes_out, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002424 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002425 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002426 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002427 last_isspace = 0;
2428 break;
2429
Willy Tarreauc5259fd2012-12-20 15:38:04 +01002430 case LOG_FMT_BYTES_UP: // %U
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002431 ret = lltoa(logs->bytes_in, tmplog, dst + maxsize - tmplog);
Willy Tarreauc5259fd2012-12-20 15:38:04 +01002432 if (ret == NULL)
2433 goto out;
2434 tmplog = ret;
2435 last_isspace = 0;
2436 break;
2437
Willy Tarreau2beef582012-12-20 17:22:52 +01002438 case LOG_FMT_CCLIENT: // %CC
Willy Tarreau57bc8912016-04-25 17:09:40 +02002439 src = txn ? txn->cli_cookie : NULL;
William Lallemand5f232402012-04-05 18:02:55 +02002440 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002441 if (ret == NULL)
William Lallemand51b5dca2012-03-26 17:52:55 +02002442 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002443 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002444 last_isspace = 0;
2445 break;
2446
Willy Tarreau2beef582012-12-20 17:22:52 +01002447 case LOG_FMT_CSERVER: // %CS
Willy Tarreau57bc8912016-04-25 17:09:40 +02002448 src = txn ? txn->srv_cookie : NULL;
William Lallemand5f232402012-04-05 18:02:55 +02002449 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002450 if (ret == NULL)
William Lallemand51b5dca2012-03-26 17:52:55 +02002451 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002452 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002453 last_isspace = 0;
2454 break;
2455
William Lallemand1d705562012-03-12 12:46:41 +01002456 case LOG_FMT_TERMSTATE: // %ts
Willy Tarreaub8bc5252018-09-05 15:51:28 +02002457 LOGCHAR(sess_term_cond[(s_flags & SF_ERR_MASK) >> SF_ERR_SHIFT]);
2458 LOGCHAR(sess_fin_state[(s_flags & SF_FINST_MASK) >> SF_FINST_SHIFT]);
Willy Tarreau6580c062012-03-12 15:09:42 +01002459 *tmplog = '\0';
2460 last_isspace = 0;
2461 break;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002462
William Lallemand1d705562012-03-12 12:46:41 +01002463 case LOG_FMT_TERMSTATE_CK: // %tsc, same as TS with cookie state (for mode HTTP)
Willy Tarreaub8bc5252018-09-05 15:51:28 +02002464 LOGCHAR(sess_term_cond[(s_flags & SF_ERR_MASK) >> SF_ERR_SHIFT]);
2465 LOGCHAR(sess_fin_state[(s_flags & SF_FINST_MASK) >> SF_FINST_SHIFT]);
Willy Tarreau57bc8912016-04-25 17:09:40 +02002466 LOGCHAR((txn && (be->ck_opts & PR_CK_ANY)) ? sess_cookie[(txn->flags & TX_CK_MASK) >> TX_CK_SHIFT] : '-');
2467 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 +01002468 last_isspace = 0;
2469 break;
2470
William Lallemand1d705562012-03-12 12:46:41 +01002471 case LOG_FMT_ACTCONN: // %ac
William Lallemand5f232402012-04-05 18:02:55 +02002472 ret = ltoa_o(actconn, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002473 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002474 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002475 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002476 last_isspace = 0;
2477 break;
2478
William Lallemand1d705562012-03-12 12:46:41 +01002479 case LOG_FMT_FECONN: // %fc
William Lallemand5f232402012-04-05 18:02:55 +02002480 ret = ltoa_o(fe->feconn, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002481 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002482 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002483 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002484 last_isspace = 0;
2485 break;
2486
William Lallemand1d705562012-03-12 12:46:41 +01002487 case LOG_FMT_BECONN: // %bc
William Lallemand5f232402012-04-05 18:02:55 +02002488 ret = ltoa_o(be->beconn, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002489 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002490 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_SRVCONN: // %sc
Willy Tarreaue1809df2018-09-05 15:30:16 +02002496 ret = ultoa_o(objt_server(s ? s->target : NULL) ?
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002497 objt_server(s->target)->cur_sess :
William Lallemand5f232402012-04-05 18:02:55 +02002498 0, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002499 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002500 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002501 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002502 last_isspace = 0;
2503 break;
2504
William Lallemand1d705562012-03-12 12:46:41 +01002505 case LOG_FMT_RETRIES: // %rq
Willy Tarreaub8bc5252018-09-05 15:51:28 +02002506 if (s_flags & SF_REDISP)
William Lallemand1d705562012-03-12 12:46:41 +01002507 LOGCHAR('+');
Willy Tarreauabd71a52018-09-04 19:21:44 +02002508 ret = ltoa_o((s && s->si[1].conn_retries > 0) ?
Willy Tarreau350f4872014-11-28 14:42:25 +01002509 (be->conn_retries - s->si[1].conn_retries) :
William Lallemand5f232402012-04-05 18:02:55 +02002510 be->conn_retries, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002511 if (ret == NULL)
William Lallemand51b5dca2012-03-26 17:52:55 +02002512 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002513 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002514 last_isspace = 0;
2515 break;
2516
William Lallemand1d705562012-03-12 12:46:41 +01002517 case LOG_FMT_SRVQUEUE: // %sq
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002518 ret = ltoa_o(logs->srv_queue_pos, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002519 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002520 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002521 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002522 last_isspace = 0;
2523 break;
2524
William Lallemand1d705562012-03-12 12:46:41 +01002525 case LOG_FMT_BCKQUEUE: // %bq
Willy Tarreau372ac5a2018-09-05 15:16:23 +02002526 ret = ltoa_o(logs->prx_queue_pos, tmplog, dst + maxsize - tmplog);
William Lallemand1d705562012-03-12 12:46:41 +01002527 if (ret == NULL)
William Lallemandbddd4fd2012-02-27 11:23:10 +01002528 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002529 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002530 last_isspace = 0;
2531 break;
2532
William Lallemand1d705562012-03-12 12:46:41 +01002533 case LOG_FMT_HDRREQUEST: // %hr
William Lallemandbddd4fd2012-02-27 11:23:10 +01002534 /* request header */
Willy Tarreaud4f91662018-09-05 15:28:07 +02002535 if (fe->nb_req_cap && s && s->req_cap) {
William Lallemandbddd4fd2012-02-27 11:23:10 +01002536 if (tmp->options & LOG_OPT_QUOTE)
2537 LOGCHAR('"');
2538 LOGCHAR('{');
2539 for (hdr = 0; hdr < fe->nb_req_cap; hdr++) {
2540 if (hdr)
2541 LOGCHAR('|');
Willy Tarreaucb7dd012015-04-03 22:16:32 +02002542 if (s->req_cap[hdr] != NULL) {
Dragan Dosen835b9212016-02-12 13:23:03 +01002543 ret = lf_encode_string(tmplog, dst + maxsize,
2544 '#', hdr_encode_map, s->req_cap[hdr], tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002545 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002546 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002547 tmplog = ret;
William Lallemand51b5dca2012-03-26 17:52:55 +02002548 }
William Lallemandbddd4fd2012-02-27 11:23:10 +01002549 }
2550 LOGCHAR('}');
William Lallemand51b5dca2012-03-26 17:52:55 +02002551 if (tmp->options & LOG_OPT_QUOTE)
2552 LOGCHAR('"');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002553 last_isspace = 0;
2554 }
William Lallemandbddd4fd2012-02-27 11:23:10 +01002555 break;
2556
William Lallemand1d705562012-03-12 12:46:41 +01002557 case LOG_FMT_HDRREQUESTLIST: // %hrl
William Lallemandbddd4fd2012-02-27 11:23:10 +01002558 /* request header list */
Willy Tarreaud4f91662018-09-05 15:28:07 +02002559 if (fe->nb_req_cap && s && s->req_cap) {
William Lallemandbddd4fd2012-02-27 11:23:10 +01002560 for (hdr = 0; hdr < fe->nb_req_cap; hdr++) {
2561 if (hdr > 0)
2562 LOGCHAR(' ');
2563 if (tmp->options & LOG_OPT_QUOTE)
2564 LOGCHAR('"');
Willy Tarreaucb7dd012015-04-03 22:16:32 +02002565 if (s->req_cap[hdr] != NULL) {
Dragan Dosen835b9212016-02-12 13:23:03 +01002566 ret = lf_encode_string(tmplog, dst + maxsize,
2567 '#', hdr_encode_map, s->req_cap[hdr], tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002568 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002569 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002570 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002571 } else if (!(tmp->options & LOG_OPT_QUOTE))
2572 LOGCHAR('-');
2573 if (tmp->options & LOG_OPT_QUOTE)
2574 LOGCHAR('"');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002575 last_isspace = 0;
2576 }
2577 }
2578 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002579
William Lallemand1d705562012-03-12 12:46:41 +01002580
2581 case LOG_FMT_HDRRESPONS: // %hs
William Lallemandbddd4fd2012-02-27 11:23:10 +01002582 /* response header */
Willy Tarreaud4f91662018-09-05 15:28:07 +02002583 if (fe->nb_rsp_cap && s && s->res_cap) {
William Lallemandbddd4fd2012-02-27 11:23:10 +01002584 if (tmp->options & LOG_OPT_QUOTE)
2585 LOGCHAR('"');
2586 LOGCHAR('{');
2587 for (hdr = 0; hdr < fe->nb_rsp_cap; hdr++) {
2588 if (hdr)
2589 LOGCHAR('|');
Willy Tarreaucb7dd012015-04-03 22:16:32 +02002590 if (s->res_cap[hdr] != NULL) {
Dragan Dosen835b9212016-02-12 13:23:03 +01002591 ret = lf_encode_string(tmplog, dst + maxsize,
2592 '#', hdr_encode_map, s->res_cap[hdr], tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002593 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002594 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002595 tmplog = ret;
William Lallemand51b5dca2012-03-26 17:52:55 +02002596 }
William Lallemandbddd4fd2012-02-27 11:23:10 +01002597 }
2598 LOGCHAR('}');
2599 last_isspace = 0;
2600 if (tmp->options & LOG_OPT_QUOTE)
2601 LOGCHAR('"');
2602 }
William Lallemandbddd4fd2012-02-27 11:23:10 +01002603 break;
2604
William Lallemand1d705562012-03-12 12:46:41 +01002605 case LOG_FMT_HDRRESPONSLIST: // %hsl
William Lallemandbddd4fd2012-02-27 11:23:10 +01002606 /* response header list */
Willy Tarreaud4f91662018-09-05 15:28:07 +02002607 if (fe->nb_rsp_cap && s && s->res_cap) {
William Lallemandbddd4fd2012-02-27 11:23:10 +01002608 for (hdr = 0; hdr < fe->nb_rsp_cap; hdr++) {
2609 if (hdr > 0)
2610 LOGCHAR(' ');
2611 if (tmp->options & LOG_OPT_QUOTE)
2612 LOGCHAR('"');
Willy Tarreaucb7dd012015-04-03 22:16:32 +02002613 if (s->res_cap[hdr] != NULL) {
Dragan Dosen835b9212016-02-12 13:23:03 +01002614 ret = lf_encode_string(tmplog, dst + maxsize,
2615 '#', hdr_encode_map, s->res_cap[hdr], tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002616 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002617 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002618 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002619 } else if (!(tmp->options & LOG_OPT_QUOTE))
2620 LOGCHAR('-');
2621 if (tmp->options & LOG_OPT_QUOTE)
2622 LOGCHAR('"');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002623 last_isspace = 0;
2624 }
2625 }
2626 break;
2627
William Lallemand1d705562012-03-12 12:46:41 +01002628 case LOG_FMT_REQ: // %r
William Lallemandbddd4fd2012-02-27 11:23:10 +01002629 /* Request */
2630 if (tmp->options & LOG_OPT_QUOTE)
2631 LOGCHAR('"');
Willy Tarreau57bc8912016-04-25 17:09:40 +02002632 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Dragan Dosen835b9212016-02-12 13:23:03 +01002633 ret = lf_encode_string(tmplog, dst + maxsize,
2634 '#', url_encode_map, uri, tmp);
William Lallemand1d705562012-03-12 12:46:41 +01002635 if (ret == NULL || *ret != '\0')
William Lallemand51b5dca2012-03-26 17:52:55 +02002636 goto out;
William Lallemand1d705562012-03-12 12:46:41 +01002637 tmplog = ret;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002638 if (tmp->options & LOG_OPT_QUOTE)
2639 LOGCHAR('"');
William Lallemandbddd4fd2012-02-27 11:23:10 +01002640 last_isspace = 0;
2641 break;
William Lallemand5f232402012-04-05 18:02:55 +02002642
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002643 case LOG_FMT_HTTP_PATH: // %HP
Willy Tarreau57bc8912016-04-25 17:09:40 +02002644 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002645
Willy Tarreaub7636d12015-06-17 19:58:02 +02002646 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002647 LOGCHAR('"');
2648
2649 end = uri + strlen(uri);
2650 // look for the first whitespace character
2651 while (uri < end && !HTTP_IS_SPHT(*uri))
2652 uri++;
2653
2654 // keep advancing past multiple spaces
2655 while (uri < end && HTTP_IS_SPHT(*uri)) {
2656 uri++; nspaces++;
2657 }
2658
2659 // look for first space or question mark after url
2660 spc = uri;
2661 while (spc < end && *spc != '?' && !HTTP_IS_SPHT(*spc))
2662 spc++;
2663
Nenad Merdanovic54e439f2016-04-26 01:39:02 +02002664 if (!txn || !txn->uri || nspaces == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002665 chunk.area = "<BADREQ>";
2666 chunk.data = strlen("<BADREQ>");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002667 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002668 chunk.area = uri;
2669 chunk.data = spc - uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002670 }
2671
Dragan Dosen835b9212016-02-12 13:23:03 +01002672 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002673 if (ret == NULL || *ret != '\0')
2674 goto out;
2675
2676 tmplog = ret;
Willy Tarreaub7636d12015-06-17 19:58:02 +02002677 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002678 LOGCHAR('"');
2679
2680 last_isspace = 0;
2681 break;
2682
Andrew Hayworthe63ac872015-07-31 16:14:16 +00002683 case LOG_FMT_HTTP_QUERY: // %HQ
2684 if (tmp->options & LOG_OPT_QUOTE)
2685 LOGCHAR('"');
2686
Willy Tarreau57bc8912016-04-25 17:09:40 +02002687 if (!txn || !txn->uri) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002688 chunk.area = "<BADREQ>";
2689 chunk.data = strlen("<BADREQ>");
Andrew Hayworthe63ac872015-07-31 16:14:16 +00002690 } else {
2691 uri = txn->uri;
2692 end = uri + strlen(uri);
2693 // look for the first question mark
2694 while (uri < end && *uri != '?')
2695 uri++;
2696
2697 qmark = uri;
2698 // look for first space or question mark after url
2699 while (uri < end && !HTTP_IS_SPHT(*uri))
2700 uri++;
2701
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002702 chunk.area = qmark;
2703 chunk.data = uri - qmark;
Andrew Hayworthe63ac872015-07-31 16:14:16 +00002704 }
2705
Dragan Dosen835b9212016-02-12 13:23:03 +01002706 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworthe63ac872015-07-31 16:14:16 +00002707 if (ret == NULL || *ret != '\0')
2708 goto out;
2709
2710 tmplog = ret;
2711 if (tmp->options & LOG_OPT_QUOTE)
2712 LOGCHAR('"');
2713
2714 last_isspace = 0;
2715 break;
2716
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002717 case LOG_FMT_HTTP_URI: // %HU
Willy Tarreau57bc8912016-04-25 17:09:40 +02002718 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002719
Willy Tarreaub7636d12015-06-17 19:58:02 +02002720 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002721 LOGCHAR('"');
2722
2723 end = uri + strlen(uri);
2724 // look for the first whitespace character
2725 while (uri < end && !HTTP_IS_SPHT(*uri))
2726 uri++;
2727
2728 // keep advancing past multiple spaces
2729 while (uri < end && HTTP_IS_SPHT(*uri)) {
2730 uri++; nspaces++;
2731 }
2732
2733 // look for first space after url
2734 spc = uri;
2735 while (spc < end && !HTTP_IS_SPHT(*spc))
2736 spc++;
2737
Willy Tarreau57bc8912016-04-25 17:09:40 +02002738 if (!txn || !txn->uri || nspaces == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002739 chunk.area = "<BADREQ>";
2740 chunk.data = strlen("<BADREQ>");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002741 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002742 chunk.area = uri;
2743 chunk.data = spc - uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002744 }
2745
Dragan Dosen835b9212016-02-12 13:23:03 +01002746 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002747 if (ret == NULL || *ret != '\0')
2748 goto out;
2749
2750 tmplog = ret;
Willy Tarreaub7636d12015-06-17 19:58:02 +02002751 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002752 LOGCHAR('"');
2753
2754 last_isspace = 0;
2755 break;
2756
2757 case LOG_FMT_HTTP_METHOD: // %HM
Willy Tarreau57bc8912016-04-25 17:09:40 +02002758 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
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 spc = uri;
2765 while (spc < end && !HTTP_IS_SPHT(*spc))
2766 spc++;
2767
2768 if (spc == end) { // odd case, we have txn->uri, but we only got a verb
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002769 chunk.area = "<BADREQ>";
2770 chunk.data = strlen("<BADREQ>");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002771 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002772 chunk.area = uri;
2773 chunk.data = spc - uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002774 }
2775
Dragan Dosen835b9212016-02-12 13:23:03 +01002776 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002777 if (ret == NULL || *ret != '\0')
2778 goto out;
2779
2780 tmplog = ret;
Willy Tarreaub7636d12015-06-17 19:58:02 +02002781 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002782 LOGCHAR('"');
2783
2784 last_isspace = 0;
2785 break;
2786
2787 case LOG_FMT_HTTP_VERSION: // %HV
Willy Tarreau57bc8912016-04-25 17:09:40 +02002788 uri = txn && txn->uri ? txn->uri : "<BADREQ>";
Willy Tarreaub7636d12015-06-17 19:58:02 +02002789 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002790 LOGCHAR('"');
2791
2792 end = uri + strlen(uri);
2793 // look for the first whitespace character
2794 while (uri < end && !HTTP_IS_SPHT(*uri))
2795 uri++;
2796
2797 // keep advancing past multiple spaces
2798 while (uri < end && HTTP_IS_SPHT(*uri)) {
2799 uri++; nspaces++;
2800 }
2801
2802 // look for the next whitespace character
2803 while (uri < end && !HTTP_IS_SPHT(*uri))
2804 uri++;
2805
2806 // keep advancing past multiple spaces
2807 while (uri < end && HTTP_IS_SPHT(*uri))
2808 uri++;
2809
Willy Tarreau57bc8912016-04-25 17:09:40 +02002810 if (!txn || !txn->uri || nspaces == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002811 chunk.area = "<BADREQ>";
2812 chunk.data = strlen("<BADREQ>");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002813 } else if (uri == end) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002814 chunk.area = "HTTP/0.9";
2815 chunk.data = strlen("HTTP/0.9");
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002816 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002817 chunk.area = uri;
2818 chunk.data = end - uri;
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002819 }
2820
Dragan Dosen835b9212016-02-12 13:23:03 +01002821 ret = lf_encode_chunk(tmplog, dst + maxsize, '#', url_encode_map, &chunk, tmp);
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002822 if (ret == NULL || *ret != '\0')
2823 goto out;
2824
2825 tmplog = ret;
Willy Tarreaub7636d12015-06-17 19:58:02 +02002826 if (tmp->options & LOG_OPT_QUOTE)
Andrew Hayworth0ebc55f2015-04-27 21:37:03 +00002827 LOGCHAR('"');
2828
2829 last_isspace = 0;
2830 break;
2831
William Lallemand5f232402012-04-05 18:02:55 +02002832 case LOG_FMT_COUNTER: // %rt
2833 if (tmp->options & LOG_OPT_HEXA) {
Willy Tarreau5cacab62018-09-05 15:52:59 +02002834 iret = snprintf(tmplog, dst + maxsize - tmplog, "%04X", uniq_id);
William Lallemand5f232402012-04-05 18:02:55 +02002835 if (iret < 0 || iret > dst + maxsize - tmplog)
2836 goto out;
2837 last_isspace = 0;
2838 tmplog += iret;
2839 } else {
Willy Tarreau5cacab62018-09-05 15:52:59 +02002840 ret = ltoa_o(uniq_id, tmplog, dst + maxsize - tmplog);
William Lallemand5f232402012-04-05 18:02:55 +02002841 if (ret == NULL)
2842 goto out;
2843 tmplog = ret;
2844 last_isspace = 0;
2845 }
2846 break;
2847
Willy Tarreau7346acb2014-08-28 15:03:15 +02002848 case LOG_FMT_LOGCNT: // %lc
2849 if (tmp->options & LOG_OPT_HEXA) {
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002850 iret = snprintf(tmplog, dst + maxsize - tmplog, "%04X", fe->log_count);
Willy Tarreau7346acb2014-08-28 15:03:15 +02002851 if (iret < 0 || iret > dst + maxsize - tmplog)
2852 goto out;
2853 last_isspace = 0;
2854 tmplog += iret;
2855 } else {
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002856 ret = ultoa_o(fe->log_count, tmplog, dst + maxsize - tmplog);
Willy Tarreau7346acb2014-08-28 15:03:15 +02002857 if (ret == NULL)
2858 goto out;
2859 tmplog = ret;
2860 last_isspace = 0;
2861 }
2862 break;
2863
William Lallemand5f232402012-04-05 18:02:55 +02002864 case LOG_FMT_HOSTNAME: // %H
2865 src = hostname;
2866 ret = lf_text(tmplog, src, dst + maxsize - tmplog, tmp);
2867 if (ret == NULL)
2868 goto out;
2869 tmplog = ret;
2870 last_isspace = 0;
2871 break;
2872
2873 case LOG_FMT_PID: // %pid
2874 if (tmp->options & LOG_OPT_HEXA) {
2875 iret = snprintf(tmplog, dst + maxsize - tmplog, "%04X", pid);
2876 if (iret < 0 || iret > dst + maxsize - tmplog)
2877 goto out;
2878 last_isspace = 0;
2879 tmplog += iret;
2880 } else {
2881 ret = ltoa_o(pid, tmplog, dst + maxsize - tmplog);
2882 if (ret == NULL)
2883 goto out;
2884 tmplog = ret;
2885 last_isspace = 0;
2886 }
2887 break;
William Lallemanda73203e2012-03-12 12:48:57 +01002888
2889 case LOG_FMT_UNIQUEID: // %ID
William Lallemand5b7ea3a2013-08-28 15:44:19 +02002890 ret = NULL;
Willy Tarreau02fdf4f2018-09-05 15:49:01 +02002891 src = s ? s->unique_id : NULL;
Thierry FOURNIER1be69102014-04-15 01:38:48 +02002892 ret = lf_text(tmplog, src, maxsize - (tmplog - dst), tmp);
William Lallemanda73203e2012-03-12 12:48:57 +01002893 if (ret == NULL)
2894 goto out;
2895 tmplog = ret;
2896 last_isspace = 0;
2897 break;
2898
William Lallemandbddd4fd2012-02-27 11:23:10 +01002899 }
2900 }
2901
2902out:
William Lallemand1d705562012-03-12 12:46:41 +01002903 /* *tmplog is a unused character */
2904 *tmplog = '\0';
Willy Tarreaudf974472012-12-28 02:44:01 +01002905 return tmplog - dst;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002906
Willy Tarreaubaaee002006-06-26 02:48:02 +02002907}
2908
William Lallemand1d705562012-03-12 12:46:41 +01002909/*
Willy Tarreau87b09662015-04-03 00:22:06 +02002910 * send a log for the stream when we have enough info about it.
William Lallemand1d705562012-03-12 12:46:41 +01002911 * Will not log if the frontend has no log defined.
2912 */
Willy Tarreau87b09662015-04-03 00:22:06 +02002913void strm_log(struct stream *s)
William Lallemand1d705562012-03-12 12:46:41 +01002914{
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002915 struct session *sess = s->sess;
William Lallemand1d705562012-03-12 12:46:41 +01002916 int size, err, level;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002917 int sd_size = 0;
William Lallemand1d705562012-03-12 12:46:41 +01002918
2919 /* if we don't want to log normal traffic, return now */
Willy Tarreaue7dff022015-04-03 01:14:29 +02002920 err = (s->flags & SF_REDISP) ||
2921 ((s->flags & SF_ERR_MASK) > SF_ERR_LOCAL) ||
2922 (((s->flags & SF_ERR_MASK) == SF_ERR_NONE) &&
Willy Tarreau350f4872014-11-28 14:42:25 +01002923 (s->si[1].conn_retries != s->be->conn_retries)) ||
Willy Tarreaueee5b512015-04-03 23:46:31 +02002924 ((sess->fe->mode == PR_MODE_HTTP) && s->txn && s->txn->status >= 500);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002925
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002926 if (!err && (sess->fe->options2 & PR_O2_NOLOGNORM))
William Lallemand1d705562012-03-12 12:46:41 +01002927 return;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002928
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002929 if (LIST_ISEMPTY(&sess->fe->logsrvs))
William Lallemand1d705562012-03-12 12:46:41 +01002930 return;
William Lallemandbddd4fd2012-02-27 11:23:10 +01002931
Willy Tarreauabcd5142013-06-11 17:18:02 +02002932 if (s->logs.level) { /* loglevel was overridden */
2933 if (s->logs.level == -1) {
2934 s->logs.logwait = 0; /* logs disabled */
2935 return;
2936 }
2937 level = s->logs.level - 1;
2938 }
2939 else {
2940 level = LOG_INFO;
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002941 if (err && (sess->fe->options2 & PR_O2_LOGERRORS))
Willy Tarreauabcd5142013-06-11 17:18:02 +02002942 level = LOG_ERR;
2943 }
William Lallemand1d705562012-03-12 12:46:41 +01002944
William Lallemand5b7ea3a2013-08-28 15:44:19 +02002945 /* if unique-id was not generated */
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002946 if (!s->unique_id && !LIST_ISEMPTY(&sess->fe->format_unique_id)) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01002947 if ((s->unique_id = pool_alloc(pool_head_uniqueid)) != NULL)
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002948 build_logline(s, s->unique_id, UNIQUEID_LEN, &sess->fe->format_unique_id);
William Lallemand5b7ea3a2013-08-28 15:44:19 +02002949 }
2950
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002951 if (!LIST_ISEMPTY(&sess->fe->logformat_sd)) {
2952 sd_size = build_logline(s, logline_rfc5424, global.max_syslog_len,
2953 &sess->fe->logformat_sd);
2954 }
2955
Dragan Dosen59cee972015-09-19 22:09:02 +02002956 size = build_logline(s, logline, global.max_syslog_len, &sess->fe->logformat);
William Lallemand1d705562012-03-12 12:46:41 +01002957 if (size > 0) {
Olivier Houchardd2ee3e72019-03-08 18:53:21 +01002958 _HA_ATOMIC_ADD(&sess->fe->log_count, 1);
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002959 __send_log(sess->fe, level, logline, size + 1, logline_rfc5424, sd_size);
William Lallemand1d705562012-03-12 12:46:41 +01002960 s->logs.logwait = 0;
2961 }
2962}
William Lallemandbddd4fd2012-02-27 11:23:10 +01002963
Willy Tarreau53839352018-09-05 19:51:10 +02002964/*
2965 * send a minimalist log for the session. Will not log if the frontend has no
2966 * log defined. It is assumed that this is only used to report anomalies that
2967 * cannot lead to the creation of a regular stream. Because of this the log
2968 * level is LOG_INFO or LOG_ERR depending on the "log-separate-error" setting
2969 * in the frontend. The caller must simply know that it should not call this
Willy Tarreau9fa267d2018-10-05 10:22:27 +02002970 * function to report unimportant events. It is safe to call this function with
2971 * sess==NULL (will not do anything).
Willy Tarreau53839352018-09-05 19:51:10 +02002972 */
2973void sess_log(struct session *sess)
2974{
2975 int size, level;
2976 int sd_size = 0;
2977
Willy Tarreau9fa267d2018-10-05 10:22:27 +02002978 if (!sess)
2979 return;
2980
Willy Tarreau53839352018-09-05 19:51:10 +02002981 if (LIST_ISEMPTY(&sess->fe->logsrvs))
2982 return;
2983
2984 level = LOG_INFO;
2985 if (sess->fe->options2 & PR_O2_LOGERRORS)
2986 level = LOG_ERR;
2987
2988 if (!LIST_ISEMPTY(&sess->fe->logformat_sd)) {
2989 sd_size = sess_build_logline(sess, NULL,
2990 logline_rfc5424, global.max_syslog_len,
2991 &sess->fe->logformat_sd);
2992 }
2993
2994 size = sess_build_logline(sess, NULL, logline, global.max_syslog_len, &sess->fe->logformat);
2995 if (size > 0) {
Olivier Houchardd2ee3e72019-03-08 18:53:21 +01002996 _HA_ATOMIC_ADD(&sess->fe->log_count, 1);
Willy Tarreau53839352018-09-05 19:51:10 +02002997 __send_log(sess->fe, level, logline, size + 1, logline_rfc5424, sd_size);
2998 }
2999}
3000
Christopher Fauletc1b730a2017-10-24 12:00:51 +02003001static int cli_io_handler_show_startup_logs(struct appctx *appctx)
3002{
3003 struct stream_interface *si = appctx->owner;
3004 const char *msg = (startup_logs ? startup_logs : "No startup alerts/warnings.\n");
3005
3006 if (ci_putstr(si_ic(si), msg) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01003007 si_rx_room_blk(si);
Christopher Fauletc1b730a2017-10-24 12:00:51 +02003008 return 0;
3009 }
3010 return 1;
3011}
3012
3013/* register cli keywords */
3014static struct cli_kw_list cli_kws = {{ },{
3015 { { "show", "startup-logs", NULL },
3016 "show startup-logs : report logs emitted during HAProxy startup",
3017 NULL, cli_io_handler_show_startup_logs },
3018 {{},}
3019}};
3020
Willy Tarreau0108d902018-11-25 19:14:37 +01003021INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3022
Willy Tarreau172f5ce2018-11-26 11:21:50 +01003023REGISTER_PER_THREAD_INIT(init_log_buffers_per_thread);
3024REGISTER_PER_THREAD_DEINIT(deinit_log_buffers_per_thread);
3025
Willy Tarreaubaaee002006-06-26 02:48:02 +02003026/*
3027 * Local variables:
3028 * c-indent-level: 8
3029 * c-basic-offset: 8
3030 * End:
3031 */