ModUdp.cc
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2022 The Squid Software Foundation and contributors
3  *
4  * Squid software is distributed under GPLv2+ license and includes
5  * contributions from numerous individuals and organizations.
6  * Please see the COPYING and CONTRIBUTORS files for details.
7  */
8 
9 /* DEBUG: section 50 Log file handling */
10 
11 #include "squid.h"
12 #include "comm.h"
13 #include "comm/Connection.h"
14 #include "fatal.h"
15 #include "fd.h"
16 #include "fs_io.h"
17 #include "log/File.h"
18 #include "log/ModUdp.h"
19 #include "Parsing.h"
20 #include "SquidConfig.h"
21 
22 #include <cerrno>
23 
24 /*
25  * This logfile UDP module is mostly inspired by a patch by Tim Starling
26  * from Wikimedia.
27  *
28  * It doesn't do any UDP buffering - it'd be quite a bit of work for
29  * something which the kernel could be doing for you!
30  */
31 
32 typedef struct {
33  int fd;
34  char *buf;
35  size_t bufsz;
36  int offset;
37 } l_udp_t;
38 
39 static void
40 logfile_mod_udp_write(Logfile * lf, const char *buf, size_t len)
41 {
42  l_udp_t *ll = (l_udp_t *) lf->data;
43  ssize_t s;
44  s = write(ll->fd, (char const *) buf, len);
45  fd_bytes(ll->fd, s, FD_WRITE);
46 #if 0
47  // TODO: Enable after polishing to properly log these errors.
48  if (s < 0) {
49  int xerrno = errno;
50  debugs(1, DBG_IMPORTANT, "logfile (udp): got errno (" << errno << "):" << xstrerr(xerrno));
51  }
52  if (s != len) {
53  debugs(1, DBG_IMPORTANT, "logfile (udp): len=" << len << ", wrote=" << s);
54  }
55 #endif
56 
57  /* We don't worry about network errors for now */
58 }
59 
60 static void
62 {
63  l_udp_t *ll = (l_udp_t *) lf->data;
64  if (0 == ll->offset)
65  return;
66  logfile_mod_udp_write(lf, ll->buf, (size_t) ll->offset);
67  ll->offset = 0;
68 }
69 
70 static void
71 logfile_mod_udp_writeline(Logfile * lf, const char *buf, size_t len)
72 {
73  l_udp_t *ll = (l_udp_t *) lf->data;
74 
75  if (0 == ll->bufsz) {
76  /* buffering disabled */
77  logfile_mod_udp_write(lf, buf, len);
78  return;
79  }
80  if (ll->offset > 0 && (ll->offset + len + 4) > ll->bufsz)
82 
83  if (len > ll->bufsz) {
84  /* too big to fit in buffer */
85  logfile_mod_udp_write(lf, buf, len);
86  return;
87  }
88  /* buffer it */
89  memcpy(ll->buf + ll->offset, buf, len);
90 
91  ll->offset += len;
92 
93  assert(ll->offset >= 0);
94 
95  assert((size_t) ll->offset <= ll->bufsz);
96 }
97 
98 static void
100 {
101 }
102 
103 static void
105 {
106 }
107 
108 static void
110 {
111 }
112 
113 static void
115 {
116  l_udp_t *ll = (l_udp_t *) lf->data;
117  lf->f_flush(lf);
118 
119  if (ll->fd >= 0)
120  file_close(ll->fd);
121 
122  if (ll->buf)
123  xfree(ll->buf);
124 
125  xfree(lf->data);
126  lf->data = NULL;
127 }
128 
129 /*
130  * This code expects the path to be //host:port
131  */
132 int
133 logfile_mod_udp_open(Logfile * lf, const char *path, size_t bufsz, int fatal_flag)
134 {
135  Ip::Address addr;
136  char *strAddr;
137 
144 
145  l_udp_t *ll = static_cast<l_udp_t*>(xcalloc(1, sizeof(*ll)));
146  lf->data = ll;
147 
148  if (strncmp(path, "//", 2) == 0) {
149  path += 2;
150  }
151  strAddr = xstrdup(path);
152  if (!GetHostWithPort(strAddr, &addr)) {
153  if (lf->flags.fatal) {
154  fatalf("Invalid UDP logging address '%s'\n", lf->path);
155  } else {
156  debugs(50, DBG_IMPORTANT, "ERROR: Invalid UDP logging address '" << lf->path << "'");
157  safe_free(strAddr);
158  return FALSE;
159  }
160  }
161  safe_free(strAddr);
162 
163  Ip::Address any_addr;
164  any_addr.setAnyAddr();
165 
166  // require the sending UDP port to be of the right family for the destination address.
167  if (addr.isIPv4())
168  any_addr.setIPv4();
169 
170  ll->fd = comm_open(SOCK_DGRAM, IPPROTO_UDP, any_addr, COMM_NONBLOCKING, "UDP log socket");
171  int xerrno = errno;
172  if (ll->fd < 0) {
173  if (lf->flags.fatal) {
174  fatalf("Unable to open UDP socket for logging\n");
175  } else {
176  debugs(50, DBG_IMPORTANT, "ERROR: Unable to open UDP socket for logging");
177  return FALSE;
178  }
179  } else if (!comm_connect_addr(ll->fd, addr)) {
180  xerrno = errno;
181  if (lf->flags.fatal) {
182  fatalf("Unable to connect to %s for UDP log: %s\n", lf->path, xstrerr(xerrno));
183  } else {
184  debugs(50, DBG_IMPORTANT, "ERROR: Unable to connect to " << lf->path << " for UDP log: " << xstrerr(xerrno));
185  return FALSE;
186  }
187  }
188  if (ll->fd == -1) {
189  if (ENOENT == xerrno && fatal_flag) {
190  fatalf("Cannot open '%s' because\n"
191  "\tthe parent directory does not exist.\n"
192  "\tPlease create the directory.\n", path);
193  } else if (EACCES == xerrno && fatal_flag) {
194  fatalf("Cannot open '%s' for writing.\n"
195  "\tThe parent directory must be writeable by the\n"
196  "\tuser '%s', which is the cache_effective_user\n"
197  "\tset in squid.conf.", path, Config.effectiveUser);
198  } else {
199  debugs(50, DBG_IMPORTANT, "logfileOpen (UDP): " << lf->path << ": " << xstrerr(xerrno));
200  return 0;
201  }
202  }
203  /* Force buffer size to something roughly fitting inside an MTU */
204  /*
205  * XXX note the receive side needs to receive the whole packet at once;
206  * applications like netcat have a small default receive buffer and will
207  * truncate!
208  */
209  if (bufsz > 1400)
210  bufsz = 1400;
211  if (bufsz > 0) {
212  ll->buf = static_cast<char*>(xmalloc(bufsz));
213  ll->bufsz = bufsz;
214  }
215 
216  return 1;
217 }
218 
const char * xstrerr(int error)
Definition: xstrerror.cc:83
static void logfile_mod_udp_linestart(Logfile *)
Definition: ModUdp.cc:99
void * xcalloc(size_t n, size_t sz)
Definition: xalloc.cc:71
#define xmalloc
#define FALSE
Definition: std-includes.h:56
char * buf
Definition: ModUdp.cc:34
int offset
Definition: ModUdp.cc:36
int comm_connect_addr(int sock, const Ip::Address &address)
Definition: comm.cc:602
#define xstrdup
bool isIPv4() const
Definition: Address.cc:158
LOGWRITE * f_linewrite
Definition: File.h:58
void file_close(int fd)
Definition: fs_io.cc:73
unsigned int fatal
Definition: File.h:49
#define COMM_NONBLOCKING
Definition: Connection.h:46
static void logfile_mod_udp_writeline(Logfile *lf, const char *buf, size_t len)
Definition: ModUdp.cc:71
void * data
Definition: File.h:55
int fd
Definition: ModUdp.cc:33
#define NULL
Definition: types.h:166
int logfile_mod_udp_open(Logfile *lf, const char *path, size_t bufsz, int fatal_flag)
Definition: ModUdp.cc:133
static void logfile_mod_udp_rotate(Logfile *, const int16_t)
Definition: ModUdp.cc:109
LOGLINEEND * f_lineend
Definition: File.h:59
#define safe_free(x)
Definition: xalloc.h:73
#define assert(EX)
Definition: assert.h:19
void fatalf(const char *fmt,...)
Definition: fatal.cc:68
bool setIPv4()
Definition: Address.cc:224
LOGCLOSE * f_close
Definition: File.h:62
int comm_open(int sock_type, int proto, Ip::Address &addr, int flags, const char *note)
Definition: comm.cc:223
LOGROTATE * f_rotate
Definition: File.h:61
static void logfile_mod_udp_write(Logfile *lf, const char *buf, size_t len)
Definition: ModUdp.cc:40
char * effectiveUser
Definition: SquidConfig.h:194
#define xfree
Definition: File.h:39
void fd_bytes(int fd, int len, unsigned int type)
Definition: fd.cc:226
static void logfile_mod_udp_flush(Logfile *lf)
Definition: ModUdp.cc:61
bool GetHostWithPort(char *token, Ip::Address *ipa)
Definition: Parsing.cc:257
size_t bufsz
Definition: ModUdp.cc:35
LOGFLUSH * f_flush
Definition: File.h:60
void setAnyAddr()
NOTE: Does NOT clear the Port stored. Only the Address and Type.
Definition: Address.cc:177
#define DBG_IMPORTANT
Definition: Stream.h:41
struct Logfile::@82 flags
static void logfile_mod_udp_close(Logfile *lf)
Definition: ModUdp.cc:114
@ FD_WRITE
Definition: enums.h:24
LOGLINESTART * f_linestart
Definition: File.h:57
static void logfile_mod_udp_lineend(Logfile *)
Definition: ModUdp.cc:104
char path[MAXPATHLEN]
Definition: File.h:46
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Stream.h:196
class SquidConfig Config
Definition: SquidConfig.cc:12

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors