← Back to branch summary

~ubuntu-branches/ubuntu/trusty/syslog-ng/trusty-proposed

« back to all changes in this revision

Viewing changes to .pc/afsocket-fixed-a-NULL-deref-in-case-of-reload.patch/modules/afsocket/afsocket.c

  • Committer: Package Import Robot
  • Author(s): Laszlo Boszormenyi (GCS), Gergely Nagy
  • Date: 2011-10-11 14:30:48 UTC
  • mfrom: (1.3.7)
  • Revision ID: package-import@ubuntu.com-20111011143048-r1iljux9xbvj3lwh
Tags: 3.3.1.dfsg-1
http://bugs.debian.org/496521
http://bugs.debian.org/616069
http://bugs.debian.org/630172
http://bugs.debian.org/609154
http://bugs.debian.org/608605
http://bugs.debian.org/644458
http://bugs.debian.org/634715
http://bugs.debian.org/589081
* New upstream release with important fixes from upstream git tree with
  non-free manpages removed.
* Drop syslog-ng.conf(5) (closes: #496521).
* syslog-ng(8) is generated, and does not mention -Q anymore
  (closes: #616069).
* Supports CAP_SYSLOG on recent kernels (closes: #630172).
* Does not use g_timeout_add_seconds anymore (closes: #609154).

[ Gergely Nagy <algernon@madhouse-project.org> ]
* Update debian/copyright to DEP-5 format.
* Simplified the logrotate file by merging identical entries.
* Include local configuration files from /etc/syslog-ng/conf.d/ (Closes:
  #609050).
* Update syslog-ng.conf to be fully 3.3 compliant.
* Compress both source and binaries (except the syslog-ng meta
  package) with xz, instead of gzip.
* Use dpkg triggers to restart syslog-ng when appropriate.
* Include DFSG-free manual pages for all binaries.
* Build with Hardening enabled.
* Mention syslog(3) in /etc/default/syslog-ng, instead of
  <linux/kernel.h> (Closes: #608605)
* Support 'status' in the init script.
  Patch from Peter Eisentraut <petere@debian.org> (Closes: #644458)
* Build-Depend on libevtlog-dev (>= 0.2.12-5~) for correct shlibs.
* Use [linux-any] in Build-Depends instead of hardcoded links.
  (Closes: #634715)
* Use $SYSLOGNG_OPTS in the init script when reloading syslog-ng.
  (Closes: #589081)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/afsocket-fixed-a-NULL-deref-in-case-of-reload.patch/modules/afsocket/afsocket.c
 
1
/*
 
2
 * Copyright (c) 2002-2010 BalaBit IT Ltd, Budapest, Hungary
 
3
 * Copyright (c) 1998-2010 Balázs Scheidler
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify it
 
6
 * under the terms of the GNU General Public License version 2 as published
 
7
 * by the Free Software Foundation, or (at your option) any later version.
 
8
 *
 
9
 * This library is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 * Lesser General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Lesser General Public
 
15
 * License along with this library; if not, write to the Free Software
 
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 *
 
18
 * As an additional exemption you are allowed to compile & link against the
 
19
 * OpenSSL libraries as published by the OpenSSL project. See the file
 
20
 * COPYING for details.
 
21
 *
 
22
 */
 
23
 
 
24
#include "afsocket.h"
 
25
#include "messages.h"
 
26
#include "driver.h"
 
27
#include "misc.h"
 
28
#include "logwriter.h"
 
29
#if ENABLE_SSL
 
30
#include "tlstransport.h"
 
31
#endif
 
32
#include "gprocess.h"
 
33
#include "gsocket.h"
 
34
#include "stats.h"
 
35
#include "mainloop.h"
 
36
 
 
37
#include <stdio.h>
 
38
#include <string.h>
 
39
#include <sys/types.h>
 
40
#include <sys/socket.h>
 
41
#include <netinet/in.h>
 
42
#include <sys/un.h>
 
43
#include <arpa/inet.h>
 
44
#include <sys/stat.h>
 
45
#include <unistd.h>
 
46
 
 
47
#if ENABLE_TCP_WRAPPER
 
48
#include <tcpd.h>
 
49
int allow_severity = 0;
 
50
int deny_severity = 0;
 
51
#endif
 
52
 
 
53
 
 
54
 
 
55
typedef struct _AFSocketSourceConnection
 
56
{
 
57
  LogPipe super;
 
58
  struct _AFSocketSourceDriver *owner;
 
59
  LogPipe *reader;
 
60
  int sock;
 
61
  GSockAddr *peer_addr;
 
62
} AFSocketSourceConnection;
 
63
 
 
64
static void afsocket_sd_close_connection(AFSocketSourceDriver *self, AFSocketSourceConnection *sc);
 
65
 
 
66
gboolean
 
67
afsocket_setup_socket(gint fd, SocketOptions *sock_options, AFSocketDirection dir)
 
68
{
 
69
  if (dir & AFSOCKET_DIR_RECV)
 
70
    {
 
71
      if (sock_options->rcvbuf)
 
72
        setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &sock_options->rcvbuf, sizeof(sock_options->rcvbuf));
 
73
    }
 
74
  if (dir & AFSOCKET_DIR_SEND)
 
75
    {
 
76
      if (sock_options->sndbuf)
 
77
        setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sock_options->sndbuf, sizeof(sock_options->sndbuf));
 
78
      if (sock_options->broadcast)
 
79
        setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &sock_options->broadcast, sizeof(sock_options->broadcast));
 
80
    }
 
81
  setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &sock_options->keepalive, sizeof(sock_options->keepalive));
 
82
  return TRUE;
 
83
}
 
84
 
 
85
static gboolean
 
86
afsocket_open_socket(GSockAddr *bind_addr, int stream_or_dgram, int *fd)
 
87
{
 
88
  gint sock;
 
89
 
 
90
  if (stream_or_dgram)
 
91
    sock = socket(bind_addr->sa.sa_family, SOCK_STREAM, 0);
 
92
  else
 
93
    sock = socket(bind_addr->sa.sa_family, SOCK_DGRAM, 0);
 
94
 
 
95
  if (sock != -1)
 
96
    {
 
97
      cap_t saved_caps;
 
98
 
 
99
      g_fd_set_nonblock(sock, TRUE);
 
100
      g_fd_set_cloexec(sock, TRUE);
 
101
      saved_caps = g_process_cap_save();
 
102
      g_process_cap_modify(CAP_NET_BIND_SERVICE, TRUE);
 
103
      g_process_cap_modify(CAP_DAC_OVERRIDE, TRUE);
 
104
      if (g_bind(sock, bind_addr) != G_IO_STATUS_NORMAL)
 
105
        {
 
106
          gchar buf[256];
 
107
 
 
108
          g_process_cap_restore(saved_caps);
 
109
          msg_error("Error binding socket",
 
110
                    evt_tag_str("addr", g_sockaddr_format(bind_addr, buf, sizeof(buf), GSA_FULL)),
 
111
                    evt_tag_errno(EVT_TAG_OSERROR, errno),
 
112
                    NULL);
 
113
          close(sock);
 
114
          return FALSE;
 
115
        }
 
116
      g_process_cap_restore(saved_caps);
 
117
 
 
118
      *fd = sock;
 
119
      return TRUE;
 
120
    }
 
121
  else
 
122
    {
 
123
      msg_error("Error creating socket",
 
124
                evt_tag_errno(EVT_TAG_OSERROR, errno),
 
125
                NULL);
 
126
      return FALSE;
 
127
    }
 
128
}
 
129
 
 
130
static gint
 
131
afsocket_sc_stats_source(AFSocketSourceConnection *self)
 
132
{
 
133
  gint source;
 
134
 
 
135
  if ((self->owner->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
 
136
    {
 
137
      switch (self->owner->bind_addr->sa.sa_family)
 
138
        {
 
139
        case AF_UNIX:
 
140
          source = !!(self->owner->flags & AFSOCKET_STREAM) ? SCS_UNIX_STREAM : SCS_UNIX_DGRAM;
 
141
          break;
 
142
        case AF_INET:
 
143
          source = !!(self->owner->flags & AFSOCKET_STREAM) ? SCS_TCP : SCS_UDP;
 
144
          break;
 
145
#if ENABLE_IPV6
 
146
        case AF_INET6:
 
147
          source = !!(self->owner->flags & AFSOCKET_STREAM) ? SCS_TCP6 : SCS_UDP6;
 
148
          break;
 
149
#endif
 
150
        default:
 
151
          g_assert_not_reached();
 
152
          break;
 
153
        }
 
154
    }
 
155
  else
 
156
    {
 
157
      source = SCS_SYSLOG;
 
158
    }
 
159
  return source;
 
160
}
 
161
 
 
162
static gchar *
 
163
afsocket_sc_stats_instance(AFSocketSourceConnection *self)
 
164
{
 
165
  static gchar buf[256];
 
166
 
 
167
  if (!self->peer_addr)
 
168
    {
 
169
      return NULL;
 
170
    }
 
171
  if ((self->owner->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
 
172
    {
 
173
      g_sockaddr_format(self->peer_addr, buf, sizeof(buf), GSA_ADDRESS_ONLY);
 
174
    }
 
175
  else
 
176
    {
 
177
      gchar peer_addr[MAX_SOCKADDR_STRING];
 
178
 
 
179
      g_sockaddr_format(self->peer_addr, peer_addr, sizeof(peer_addr), GSA_ADDRESS_ONLY);
 
180
      g_snprintf(buf, sizeof(buf), "%s,%s", self->owner->transport, peer_addr);
 
181
    }
 
182
  return buf;
 
183
}
 
184
 
 
185
static gboolean
 
186
afsocket_sc_init(LogPipe *s)
 
187
{
 
188
  AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
 
189
  gint read_flags;
 
190
  LogTransport *transport;
 
191
  LogProto *proto;
 
192
 
 
193
  read_flags = ((self->owner->flags & AFSOCKET_DGRAM) ? LTF_RECV : 0);
 
194
  if (!self->reader)
 
195
    {
 
196
#if ENABLE_SSL
 
197
      if (self->owner->tls_context)
 
198
        {
 
199
          TLSSession *tls_session = tls_context_setup_session(self->owner->tls_context);
 
200
          if (!tls_session)
 
201
            return FALSE;
 
202
          transport = log_transport_tls_new(tls_session, self->sock, read_flags);
 
203
        }
 
204
      else
 
205
#endif
 
206
        transport = log_transport_plain_new(self->sock, read_flags);
 
207
 
 
208
      if ((self->owner->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
 
209
        {
 
210
          /* plain protocol */
 
211
 
 
212
          if (self->owner->flags & AFSOCKET_DGRAM)
 
213
            proto = log_proto_dgram_server_new(transport, self->owner->reader_options.msg_size, 0);
 
214
          else if (self->owner->reader_options.padding)
 
215
            proto = log_proto_record_server_new(transport, self->owner->reader_options.padding, 0);
 
216
          else
 
217
            proto = log_proto_text_server_new(transport, self->owner->reader_options.msg_size, 0);
 
218
        }
 
219
      else
 
220
        {
 
221
          if (self->owner->flags & AFSOCKET_DGRAM)
 
222
            {
 
223
              /* plain protocol */
 
224
              proto = log_proto_dgram_server_new(transport, self->owner->reader_options.msg_size, 0);
 
225
            }
 
226
          else
 
227
            {
 
228
              /* framed protocol */
 
229
              proto = log_proto_framed_server_new(transport, self->owner->reader_options.msg_size);
 
230
            }
 
231
        }
 
232
 
 
233
      self->reader = log_reader_new(proto);
 
234
    }
 
235
  log_reader_set_options(self->reader, s, &self->owner->reader_options, 1, afsocket_sc_stats_source(self), self->owner->super.super.id, afsocket_sc_stats_instance(self));
 
236
  log_reader_set_peer_addr(self->reader, self->peer_addr);
 
237
  log_pipe_append(self->reader, s);
 
238
  if (log_pipe_init(self->reader, NULL))
 
239
    {
 
240
      return TRUE;
 
241
    }
 
242
  else
 
243
    {
 
244
      log_pipe_unref(self->reader);
 
245
      self->reader = NULL;
 
246
    }
 
247
  return FALSE;
 
248
}
 
249
 
 
250
static gboolean
 
251
afsocket_sc_deinit(LogPipe *s)
 
252
{
 
253
  AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
 
254
 
 
255
  log_pipe_unref(&self->owner->super.super.super);
 
256
  self->owner = NULL;
 
257
 
 
258
  log_pipe_deinit(self->reader);
 
259
  return TRUE;
 
260
}
 
261
 
 
262
static void
 
263
afsocket_sc_notify(LogPipe *s, LogPipe *sender, gint notify_code, gpointer user_data)
 
264
{
 
265
  AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
 
266
 
 
267
  switch (notify_code)
 
268
    {
 
269
    case NC_CLOSE:
 
270
    case NC_READ_ERROR:
 
271
      {
 
272
        if (self->owner->flags & AFSOCKET_STREAM)
 
273
          afsocket_sd_close_connection(self->owner, self);
 
274
        break;
 
275
      }
 
276
    }
 
277
}
 
278
 
 
279
static void
 
280
afsocket_sc_set_owner(AFSocketSourceConnection *self, AFSocketSourceDriver *owner)
 
281
{
 
282
  if (self->owner)
 
283
    {
 
284
      log_pipe_unref(&self->owner->super.super.super);
 
285
    }
 
286
  self->owner = owner;
 
287
  log_pipe_ref(&owner->super.super.super);
 
288
 
 
289
  log_pipe_append(&self->super, &owner->super.super.super);
 
290
}
 
291
 
 
292
 
 
293
/*
 
294
  This should be called by log_reader_free -> log_pipe_unref
 
295
  because this is the control pipe of the reader
 
296
*/
 
297
static void
 
298
afsocket_sc_free(LogPipe *s)
 
299
{
 
300
  AFSocketSourceConnection *self = (AFSocketSourceConnection *) s;
 
301
  g_sockaddr_unref(self->peer_addr);
 
302
  log_pipe_free_method(s);
 
303
}
 
304
 
 
305
AFSocketSourceConnection *
 
306
afsocket_sc_new(AFSocketSourceDriver *owner, GSockAddr *peer_addr, int fd)
 
307
{
 
308
  AFSocketSourceConnection *self = g_new0(AFSocketSourceConnection, 1);
 
309
 
 
310
  log_pipe_init_instance(&self->super);
 
311
  self->super.init = afsocket_sc_init;
 
312
  self->super.deinit = afsocket_sc_deinit;
 
313
  self->super.notify = afsocket_sc_notify;
 
314
  self->super.free_fn = afsocket_sc_free;
 
315
  log_pipe_ref(&owner->super.super.super);
 
316
  self->owner = owner;
 
317
 
 
318
 
 
319
  self->peer_addr = g_sockaddr_ref(peer_addr);
 
320
  self->sock = fd;
 
321
  return self;
 
322
}
 
323
 
 
324
void
 
325
afsocket_sd_set_transport(LogDriver *s, const gchar *transport)
 
326
{
 
327
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
328
 
 
329
  if (self->transport)
 
330
    g_free(self->transport);
 
331
  self->transport = g_strdup(transport);
 
332
}
 
333
 
 
334
void
 
335
afsocket_sd_add_connection(AFSocketSourceDriver *self, AFSocketSourceConnection *connection)
 
336
{
 
337
  self->connections = g_list_prepend(self->connections,connection);
 
338
}
 
339
 
 
340
void
 
341
afsocket_sd_remove_and_kill_connection(AFSocketSourceDriver *self, AFSocketSourceConnection *connection)
 
342
{
 
343
  self->connections = g_list_remove(self->connections, connection);
 
344
 
 
345
  log_pipe_deinit(&connection->super);
 
346
 
 
347
  /* Remove the circular reference between the connection and its
 
348
   * reader (through the connection->reader and reader->control
 
349
   * pointers these have a circular references).
 
350
   */
 
351
  log_pipe_unref(connection->reader);
 
352
  connection->reader = NULL;
 
353
 
 
354
  log_pipe_unref(&connection->super);
 
355
}
 
356
 
 
357
static void
 
358
afsocket_sd_kill_connection_list(GList *list)
 
359
{
 
360
  GList *l, *next;
 
361
 
 
362
  for (l = list; l; l = next)
 
363
    {
 
364
      AFSocketSourceConnection *connection = (AFSocketSourceConnection *) l->data;
 
365
 
 
366
      next = l->next;
 
367
      afsocket_sd_remove_and_kill_connection(connection->owner, connection);
 
368
    }
 
369
}
 
370
 
 
371
void
 
372
afsocket_sd_set_keep_alive(LogDriver *s, gint enable)
 
373
{
 
374
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
375
 
 
376
  if (enable)
 
377
    self->flags |= AFSOCKET_KEEP_ALIVE;
 
378
  else
 
379
    self->flags &= ~AFSOCKET_KEEP_ALIVE;
 
380
}
 
381
 
 
382
void
 
383
afsocket_sd_set_max_connections(LogDriver *s, gint max_connections)
 
384
{
 
385
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
386
 
 
387
  self->max_connections = max_connections;
 
388
}
 
389
 
 
390
#if ENABLE_SSL
 
391
void
 
392
afsocket_sd_set_tls_context(LogDriver *s, TLSContext *tls_context)
 
393
{
 
394
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
395
 
 
396
  self->tls_context = tls_context;
 
397
}
 
398
#endif
 
399
 
 
400
static inline gchar *
 
401
afsocket_sd_format_persist_name(AFSocketSourceDriver *self, gboolean listener_name)
 
402
{
 
403
  static gchar persist_name[128];
 
404
  gchar buf[64];
 
405
 
 
406
  g_snprintf(persist_name, sizeof(persist_name),
 
407
             listener_name ? "afsocket_sd_listen_fd(%s,%s)" : "afsocket_sd_connections(%s,%s)",
 
408
             !!(self->flags & AFSOCKET_STREAM) ? "stream" : "dgram",
 
409
             g_sockaddr_format(self->bind_addr, buf, sizeof(buf), GSA_FULL));
 
410
  return persist_name;
 
411
}
 
412
 
 
413
gboolean
 
414
afsocket_sd_process_connection(AFSocketSourceDriver *self, GSockAddr *client_addr, GSockAddr *local_addr, gint fd)
 
415
{
 
416
  gchar buf[MAX_SOCKADDR_STRING], buf2[MAX_SOCKADDR_STRING];
 
417
#if ENABLE_TCP_WRAPPER
 
418
  if (client_addr && (client_addr->sa.sa_family == AF_INET
 
419
#if ENABLE_IPV6
 
420
                   || client_addr->sa.sa_family == AF_INET6
 
421
#endif
 
422
     ))
 
423
    {
 
424
      struct request_info req;
 
425
 
 
426
      request_init(&req, RQ_DAEMON, "syslog-ng", RQ_FILE, fd, 0);
 
427
      fromhost(&req);
 
428
      if (hosts_access(&req) == 0)
 
429
        {
 
430
 
 
431
          msg_error("Syslog connection rejected by tcpd",
 
432
                    evt_tag_str("client", g_sockaddr_format(client_addr, buf, sizeof(buf), GSA_FULL)),
 
433
                    evt_tag_str("local", g_sockaddr_format(local_addr, buf2, sizeof(buf2), GSA_FULL)),
 
434
                    NULL);
 
435
          return FALSE;
 
436
        }
 
437
    }
 
438
 
 
439
#endif
 
440
 
 
441
  if (self->num_connections >= self->max_connections)
 
442
    {
 
443
      msg_error("Number of allowed concurrent connections reached, rejecting connection",
 
444
                evt_tag_str("client", g_sockaddr_format(client_addr, buf, sizeof(buf), GSA_FULL)),
 
445
                evt_tag_str("local", g_sockaddr_format(local_addr, buf2, sizeof(buf2), GSA_FULL)),
 
446
                evt_tag_int("max", self->max_connections),
 
447
                NULL);
 
448
      return FALSE;
 
449
    }
 
450
  else
 
451
    {
 
452
      AFSocketSourceConnection *conn;
 
453
 
 
454
      conn = afsocket_sc_new(self, client_addr, fd);
 
455
      if (log_pipe_init(&conn->super, NULL))
 
456
        {
 
457
          afsocket_sd_add_connection(self,conn);
 
458
          self->num_connections++;
 
459
          log_pipe_append(&conn->super, &self->super.super.super);
 
460
        }
 
461
      else
 
462
        {
 
463
          log_pipe_unref(&conn->super);
 
464
          return FALSE;
 
465
        }
 
466
    }
 
467
  return TRUE;
 
468
}
 
469
 
 
470
#define MAX_ACCEPTS_AT_A_TIME 30
 
471
 
 
472
static void
 
473
afsocket_sd_accept(gpointer s)
 
474
{
 
475
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
476
  GSockAddr *peer_addr;
 
477
  gchar buf1[256], buf2[256];
 
478
  gint new_fd;
 
479
  gboolean res;
 
480
  int accepts = 0;
 
481
 
 
482
  while (accepts < MAX_ACCEPTS_AT_A_TIME)
 
483
    {
 
484
      GIOStatus status;
 
485
 
 
486
      status = g_accept(self->fd, &new_fd, &peer_addr);
 
487
      if (status == G_IO_STATUS_AGAIN)
 
488
        {
 
489
          /* no more connections to accept */
 
490
          break;
 
491
        }
 
492
      else if (status != G_IO_STATUS_NORMAL)
 
493
        {
 
494
          msg_error("Error accepting new connection",
 
495
                    evt_tag_errno(EVT_TAG_OSERROR, errno),
 
496
                    NULL);
 
497
          return;
 
498
        }
 
499
      if (self->setup_socket && !self->setup_socket(self, new_fd))
 
500
        {
 
501
          close(new_fd);
 
502
          return;
 
503
        }
 
504
 
 
505
      g_fd_set_nonblock(new_fd, TRUE);
 
506
      g_fd_set_cloexec(new_fd, TRUE);
 
507
 
 
508
      res = afsocket_sd_process_connection(self, peer_addr, self->bind_addr, new_fd);
 
509
 
 
510
      if (res)
 
511
        {
 
512
          if (peer_addr->sa.sa_family != AF_UNIX)
 
513
            msg_notice("Syslog connection accepted",
 
514
                        evt_tag_int("fd", new_fd),
 
515
                        evt_tag_str("client", g_sockaddr_format(peer_addr, buf1, sizeof(buf1), GSA_FULL)),
 
516
                        evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf2, sizeof(buf2), GSA_FULL)),
 
517
                        NULL);
 
518
          else
 
519
            msg_verbose("Syslog connection accepted",
 
520
                        evt_tag_int("fd", new_fd),
 
521
                        evt_tag_str("client", g_sockaddr_format(peer_addr, buf1, sizeof(buf1), GSA_FULL)),
 
522
                        evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf2, sizeof(buf2), GSA_FULL)),
 
523
                        NULL);
 
524
        }
 
525
      else
 
526
        {
 
527
          close(new_fd);
 
528
        }
 
529
 
 
530
      g_sockaddr_unref(peer_addr);
 
531
      accepts++;
 
532
    }
 
533
  return;
 
534
}
 
535
 
 
536
static void
 
537
afsocket_sd_close_connection(AFSocketSourceDriver *self, AFSocketSourceConnection *sc)
 
538
{
 
539
  gchar buf1[MAX_SOCKADDR_STRING], buf2[MAX_SOCKADDR_STRING];
 
540
 
 
541
  if (sc->peer_addr->sa.sa_family != AF_UNIX)
 
542
    msg_notice("Syslog connection closed",
 
543
               evt_tag_int("fd", sc->sock),
 
544
               evt_tag_str("client", g_sockaddr_format(sc->peer_addr, buf1, sizeof(buf1), GSA_FULL)),
 
545
               evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf2, sizeof(buf2), GSA_FULL)),
 
546
               NULL);
 
547
  else
 
548
    msg_verbose("Syslog connection closed",
 
549
               evt_tag_int("fd", sc->sock),
 
550
               evt_tag_str("client", g_sockaddr_format(sc->peer_addr, buf1, sizeof(buf1), GSA_FULL)),
 
551
               evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf2, sizeof(buf2), GSA_FULL)),
 
552
               NULL);
 
553
  log_pipe_deinit(&sc->super);
 
554
  afsocket_sd_remove_and_kill_connection(self, sc);
 
555
  self->num_connections--;
 
556
}
 
557
 
 
558
static void
 
559
afsocket_sd_start_watches(AFSocketSourceDriver *self)
 
560
{
 
561
  IV_FD_INIT(&self->listen_fd);
 
562
  self->listen_fd.fd = self->fd;
 
563
  self->listen_fd.cookie = self;
 
564
  self->listen_fd.handler_in = afsocket_sd_accept;
 
565
  iv_fd_register(&self->listen_fd);
 
566
}
 
567
 
 
568
static void
 
569
afsocket_sd_stop_watches(AFSocketSourceDriver *self)
 
570
{
 
571
  if (iv_fd_registered (&self->listen_fd))
 
572
    iv_fd_unregister(&self->listen_fd);
 
573
}
 
574
 
 
575
gboolean
 
576
afsocket_sd_init(LogPipe *s)
 
577
{
 
578
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
579
  gint sock;
 
580
  gboolean res = FALSE;
 
581
  GlobalConfig *cfg = log_pipe_get_config(s);
 
582
 
 
583
  if (!log_src_driver_init_method(s))
 
584
    return FALSE;
 
585
 
 
586
  if (!afsocket_sd_apply_transport(self))
 
587
    return FALSE;
 
588
 
 
589
  g_assert(self->transport);
 
590
  g_assert(self->bind_addr);
 
591
 
 
592
  if ((self->flags & (AFSOCKET_STREAM + AFSOCKET_WNDSIZE_INITED)) == AFSOCKET_STREAM)
 
593
    {
 
594
      /* distribute the window evenly between each of our possible
 
595
       * connections.  This is quite pessimistic and can result in very low
 
596
       * window sizes. Increase that but warn the user at the same time
 
597
       */
 
598
 
 
599
      self->reader_options.super.init_window_size /= self->max_connections;
 
600
      if (self->reader_options.super.init_window_size < 100)
 
601
        {
 
602
          msg_warning("WARNING: window sizing for tcp sources were changed in syslog-ng 3.3, the configuration value was divided by the value of max-connections(). The result was too small, clamping to 100 entries. Ensure you have a proper log_fifo_size setting to avoid message loss.",
 
603
                      evt_tag_int("orig_log_iw_size", self->reader_options.super.init_window_size),
 
604
                      evt_tag_int("new_log_iw_size", 100),
 
605
                      evt_tag_int("min_log_fifo_size", 100 * self->max_connections),
 
606
                      NULL);
 
607
          self->reader_options.super.init_window_size = 100;
 
608
        }
 
609
      self->flags |= AFSOCKET_WNDSIZE_INITED;
 
610
    }
 
611
  log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
 
612
 
 
613
  /* fetch persistent connections first */
 
614
  if ((self->flags & AFSOCKET_KEEP_ALIVE))
 
615
    {
 
616
      GList *p;
 
617
 
 
618
      self->connections = cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, FALSE));
 
619
 
 
620
      for (p = self->connections; p; p = p->next)
 
621
        {
 
622
          afsocket_sc_set_owner((AFSocketSourceConnection *) p->data, self);
 
623
          log_pipe_init((LogPipe *) p->data, NULL);
 
624
        }
 
625
    }
 
626
 
 
627
  /* ok, we have connection list, check if we need to open a listener */
 
628
  sock = -1;
 
629
  if (self->flags & AFSOCKET_STREAM)
 
630
    {
 
631
      if (self->flags & AFSOCKET_KEEP_ALIVE)
 
632
        {
 
633
          /* NOTE: this assumes that fd 0 will never be used for listening fds,
 
634
           * main.c opens fd 0 so this assumption can hold */
 
635
          sock = GPOINTER_TO_UINT(cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, TRUE))) - 1;
 
636
        }
 
637
 
 
638
      if (sock == -1)
 
639
        {
 
640
          if (!afsocket_sd_acquire_socket(self, &sock))
 
641
            return self->super.super.optional;
 
642
          if (sock == -1 && !afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
 
643
            return self->super.super.optional;
 
644
        }
 
645
 
 
646
      /* set up listening source */
 
647
      if (listen(sock, self->listen_backlog) < 0)
 
648
        {
 
649
          msg_error("Error during listen()",
 
650
                    evt_tag_errno(EVT_TAG_OSERROR, errno),
 
651
                    NULL);
 
652
          close(sock);
 
653
          return FALSE;
 
654
        }
 
655
 
 
656
      if (self->setup_socket && !self->setup_socket(self, sock))
 
657
        {
 
658
          close(sock);
 
659
          return FALSE;
 
660
        }
 
661
 
 
662
      self->fd = sock;
 
663
      afsocket_sd_start_watches(self);
 
664
      res = TRUE;
 
665
    }
 
666
  else
 
667
    {
 
668
      if (!self->connections)
 
669
        {
 
670
          if (!afsocket_sd_acquire_socket(self, &sock))
 
671
            return self->super.super.optional;
 
672
          if (sock == -1 && !afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
 
673
            return self->super.super.optional;
 
674
        }
 
675
      self->fd = -1;
 
676
 
 
677
      if (!self->setup_socket(self, sock))
 
678
        {
 
679
          close(sock);
 
680
          return FALSE;
 
681
        }
 
682
 
 
683
      /* we either have self->connections != NULL, or sock contains a new fd */
 
684
      if (self->connections || afsocket_sd_process_connection(self, NULL, self->bind_addr, sock))
 
685
        res = TRUE;
 
686
    }
 
687
  return res;
 
688
}
 
689
 
 
690
static void
 
691
afsocket_sd_close_fd(gpointer value)
 
692
{
 
693
  gint fd = GPOINTER_TO_UINT(value) - 1;
 
694
  close(fd);
 
695
}
 
696
 
 
697
gboolean
 
698
afsocket_sd_deinit(LogPipe *s)
 
699
{
 
700
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
701
  GlobalConfig *cfg = log_pipe_get_config(s);
 
702
 
 
703
  if ((self->flags & AFSOCKET_KEEP_ALIVE) == 0 || !cfg->persist)
 
704
    {
 
705
      afsocket_sd_kill_connection_list(self->connections);
 
706
    }
 
707
  else
 
708
    {
 
709
      GList *p;
 
710
 
 
711
      /* for AFSOCKET_STREAM source drivers this is a list, for
 
712
       * AFSOCKET_DGRAM this is a single connection */
 
713
 
 
714
      for (p = self->connections; p; p = p->next)
 
715
        {
 
716
          log_pipe_deinit((LogPipe *) p->data);
 
717
        }
 
718
      cfg_persist_config_add(cfg, afsocket_sd_format_persist_name(self, FALSE), self->connections, (GDestroyNotify) afsocket_sd_kill_connection_list, FALSE);
 
719
    }
 
720
  self->connections = NULL;
 
721
 
 
722
  if (self->flags & AFSOCKET_STREAM)
 
723
    {
 
724
      afsocket_sd_stop_watches(self);
 
725
      if ((self->flags & AFSOCKET_KEEP_ALIVE) == 0)
 
726
        {
 
727
          msg_verbose("Closing listener fd",
 
728
                      evt_tag_int("fd", self->fd),
 
729
                      NULL);
 
730
          close(self->fd);
 
731
        }
 
732
      else
 
733
        {
 
734
          /* NOTE: the fd is incremented by one when added to persistent config
 
735
           * as persist config cannot store NULL */
 
736
 
 
737
          cfg_persist_config_add(cfg, afsocket_sd_format_persist_name(self, TRUE), GUINT_TO_POINTER(self->fd + 1), afsocket_sd_close_fd, FALSE);
 
738
        }
 
739
    }
 
740
  else if (self->flags & AFSOCKET_DGRAM)
 
741
    {
 
742
      /* we don't need to close the listening fd here as we have a
 
743
       * single connection which will close it */
 
744
 
 
745
      ;
 
746
    }
 
747
 
 
748
  if (!log_src_driver_deinit_method(s))
 
749
    return FALSE;
 
750
 
 
751
  return TRUE;
 
752
}
 
753
 
 
754
static void
 
755
afsocket_sd_notify(LogPipe *s, LogPipe *sender, gint notify_code, gpointer user_data)
 
756
{
 
757
  switch (notify_code)
 
758
    {
 
759
    case NC_CLOSE:
 
760
    case NC_READ_ERROR:
 
761
      {
 
762
        g_assert_not_reached();
 
763
        break;
 
764
      }
 
765
    }
 
766
}
 
767
 
 
768
static gboolean
 
769
afsocket_sd_setup_socket(AFSocketSourceDriver *self, gint fd)
 
770
{
 
771
  return afsocket_setup_socket(fd, self->sock_options_ptr, AFSOCKET_DIR_RECV);
 
772
}
 
773
 
 
774
void
 
775
afsocket_sd_free(LogPipe *s)
 
776
{
 
777
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
778
 
 
779
  log_reader_options_destroy(&self->reader_options);
 
780
  g_sockaddr_unref(self->bind_addr);
 
781
  self->bind_addr = NULL;
 
782
  g_free(self->transport);
 
783
 
 
784
  log_src_driver_free(s);
 
785
}
 
786
 
 
787
void
 
788
afsocket_sd_init_instance(AFSocketSourceDriver *self, SocketOptions *sock_options, gint family, guint32 flags)
 
789
{
 
790
  log_src_driver_init_instance(&self->super);
 
791
 
 
792
  self->super.super.super.init = afsocket_sd_init;
 
793
  self->super.super.super.deinit = afsocket_sd_deinit;
 
794
  self->super.super.super.free_fn = afsocket_sd_free;
 
795
  /* NULL behaves as if log_pipe_forward_msg was specified */
 
796
  self->super.super.super.queue = NULL;
 
797
  self->super.super.super.notify = afsocket_sd_notify;
 
798
  self->sock_options_ptr = sock_options;
 
799
  self->setup_socket = afsocket_sd_setup_socket;
 
800
  self->address_family = family;
 
801
  self->max_connections = 10;
 
802
  self->listen_backlog = 255;
 
803
  self->flags = flags | AFSOCKET_KEEP_ALIVE;
 
804
  log_reader_options_defaults(&self->reader_options);
 
805
  if (self->flags & AFSOCKET_STREAM)
 
806
    self->reader_options.super.init_window_size = 1000;
 
807
 
 
808
  if (self->flags & AFSOCKET_LOCAL)
 
809
    {
 
810
      static gboolean warned = FALSE;
 
811
 
 
812
      self->reader_options.parse_options.flags |= LP_LOCAL;
 
813
      if (configuration && configuration->version < 0x0302)
 
814
        {
 
815
          if (!warned)
 
816
            {
 
817
              msg_warning("WARNING: the expected message format is being changed for unix-domain transports to improve "
 
818
                          "syslogd compatibity with syslog-ng 3.2. If you are using custom "
 
819
                          "applications which bypass the syslog() API, you might "
 
820
                          "need the 'expect-hostname' flag to get the old behaviour back", NULL);
 
821
              warned = TRUE;
 
822
            }
 
823
        }
 
824
      else
 
825
        {
 
826
          self->reader_options.parse_options.flags &= ~LP_EXPECT_HOSTNAME;
 
827
        }
 
828
    }
 
829
  if ((self->flags & AFSOCKET_SYSLOG_PROTOCOL))
 
830
    {
 
831
      self->reader_options.parse_options.flags |= LP_SYSLOG_PROTOCOL;
 
832
    }
 
833
}
 
834
 
 
835
/* socket destinations */
 
836
 
 
837
void
 
838
afsocket_dd_set_transport(LogDriver *s, const gchar *transport)
 
839
{
 
840
  AFSocketDestDriver *self = (AFSocketDestDriver *) s;
 
841
 
 
842
  if (self->transport)
 
843
    g_free(self->transport);
 
844
  self->transport = g_strdup(transport);
 
845
}
 
846
 
 
847
#if ENABLE_SSL
 
848
void
 
849
afsocket_dd_set_tls_context(LogDriver *s, TLSContext *tls_context)
 
850
{
 
851
  AFSocketDestDriver *self = (AFSocketDestDriver *) s;
 
852
 
 
853
  self->tls_context = tls_context;
 
854
}
 
855
#endif
 
856
 
 
857
void
 
858
afsocket_dd_set_keep_alive(LogDriver *s, gint enable)
 
859
{
 
860
  AFSocketDestDriver *self = (AFSocketDestDriver *) s;
 
861
 
 
862
  if (enable)
 
863
    self->flags |= AFSOCKET_KEEP_ALIVE;
 
864
  else
 
865
    self->flags &= ~AFSOCKET_KEEP_ALIVE;
 
866
}
 
867
 
 
868
 
 
869
static gchar *
 
870
afsocket_dd_format_persist_name(AFSocketDestDriver *self, gboolean qfile)
 
871
{
 
872
  static gchar persist_name[128];
 
873
 
 
874
  g_snprintf(persist_name, sizeof(persist_name),
 
875
             qfile ? "afsocket_dd_qfile(%s,%s)" : "afsocket_dd_connection(%s,%s)",
 
876
             !!(self->flags & AFSOCKET_STREAM) ? "stream" : "dgram",
 
877
             self->dest_name);
 
878
  return persist_name;
 
879
}
 
880
 
 
881
 
 
882
static gint
 
883
afsocket_dd_stats_source(AFSocketDestDriver *self)
 
884
{
 
885
  gint source = 0;
 
886
 
 
887
  if ((self->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
 
888
    {
 
889
      switch (self->dest_addr->sa.sa_family)
 
890
        {
 
891
        case AF_UNIX:
 
892
          source = !!(self->flags & AFSOCKET_STREAM) ? SCS_UNIX_STREAM : SCS_UNIX_DGRAM;
 
893
          break;
 
894
        case AF_INET:
 
895
          source = !!(self->flags & AFSOCKET_STREAM) ? SCS_TCP : SCS_UDP;
 
896
          break;
 
897
#if ENABLE_IPV6
 
898
        case AF_INET6:
 
899
          source = !!(self->flags & AFSOCKET_STREAM) ? SCS_TCP6 : SCS_UDP6;
 
900
          break;
 
901
#endif
 
902
        default:
 
903
          g_assert_not_reached();
 
904
          break;
 
905
        }
 
906
    }
 
907
  else
 
908
    {
 
909
      source = SCS_SYSLOG;
 
910
    }
 
911
  return source;
 
912
}
 
913
 
 
914
static gchar *
 
915
afsocket_dd_stats_instance(AFSocketDestDriver *self)
 
916
{
 
917
  if ((self->flags & AFSOCKET_SYSLOG_PROTOCOL) == 0)
 
918
    {
 
919
      return self->dest_name;
 
920
    }
 
921
  else
 
922
    {
 
923
      static gchar buf[256];
 
924
 
 
925
      g_snprintf(buf, sizeof(buf), "%s,%s", self->transport, self->dest_name);
 
926
      return buf;
 
927
    }
 
928
}
 
929
 
 
930
#if ENABLE_SSL
 
931
static gint
 
932
afsocket_dd_tls_verify_callback(gint ok, X509_STORE_CTX *ctx, gpointer user_data)
 
933
{
 
934
  AFSocketDestDriver *self = (AFSocketDestDriver *) user_data;
 
935
 
 
936
  if (ok && ctx->current_cert == ctx->cert && self->hostname && (self->tls_context->verify_mode & TVM_TRUSTED))
 
937
    {
 
938
      ok = tls_verify_certificate_name(ctx->cert, self->hostname);
 
939
    }
 
940
 
 
941
  return ok;
 
942
}
 
943
#endif
 
944
 
 
945
static gboolean afsocket_dd_connected(AFSocketDestDriver *self);
 
946
static void afsocket_dd_reconnect(AFSocketDestDriver *self);
 
947
 
 
948
static void
 
949
afsocket_dd_init_watches(AFSocketDestDriver *self)
 
950
{
 
951
  IV_FD_INIT(&self->connect_fd);
 
952
  self->connect_fd.cookie = self;
 
953
  self->connect_fd.handler_out = (void (*)(void *)) afsocket_dd_connected;
 
954
 
 
955
  IV_TIMER_INIT(&self->reconnect_timer);
 
956
  self->reconnect_timer.cookie = self;
 
957
  self->reconnect_timer.handler = (void (*)(void *)) afsocket_dd_reconnect;
 
958
}
 
959
 
 
960
static void
 
961
afsocket_dd_start_watches(AFSocketDestDriver *self)
 
962
{
 
963
  main_loop_assert_main_thread();
 
964
 
 
965
  self->connect_fd.fd = self->fd;
 
966
  iv_fd_register(&self->connect_fd);
 
967
}
 
968
 
 
969
static void
 
970
afsocket_dd_stop_watches(AFSocketDestDriver *self)
 
971
{
 
972
  main_loop_assert_main_thread();
 
973
 
 
974
  if (iv_fd_registered(&self->connect_fd))
 
975
    {
 
976
      iv_fd_unregister(&self->connect_fd);
 
977
 
 
978
      /* need to close the fd in this case as it wasn't established yet */
 
979
      msg_verbose("Closing connecting fd",
 
980
                  evt_tag_int("fd", self->fd),
 
981
                  NULL);
 
982
      close(self->fd);
 
983
    }
 
984
  if (iv_timer_registered(&self->reconnect_timer))
 
985
    iv_timer_unregister(&self->reconnect_timer);
 
986
}
 
987
 
 
988
static void
 
989
afsocket_dd_start_reconnect_timer(AFSocketDestDriver *self)
 
990
{
 
991
  main_loop_assert_main_thread();
 
992
 
 
993
  if (iv_timer_registered(&self->reconnect_timer))
 
994
    iv_timer_unregister(&self->reconnect_timer);
 
995
  iv_validate_now();
 
996
 
 
997
  self->reconnect_timer.expires = iv_now;
 
998
  timespec_add_msec(&self->reconnect_timer.expires, self->time_reopen * 1000);
 
999
  iv_timer_register(&self->reconnect_timer);
 
1000
}
 
1001
 
 
1002
static gboolean
 
1003
afsocket_dd_connected(AFSocketDestDriver *self)
 
1004
{
 
1005
  gchar buf1[256], buf2[256];
 
1006
  int error = 0;
 
1007
  socklen_t errorlen = sizeof(error);
 
1008
  LogTransport *transport;
 
1009
  LogProto *proto;
 
1010
  guint32 transport_flags = 0;
 
1011
 
 
1012
  main_loop_assert_main_thread();
 
1013
 
 
1014
  if (iv_fd_registered(&self->connect_fd))
 
1015
    iv_fd_unregister(&self->connect_fd);
 
1016
 
 
1017
  if (self->flags & AFSOCKET_STREAM)
 
1018
    {
 
1019
      transport_flags |= LTF_SHUTDOWN;
 
1020
      if (getsockopt(self->fd, SOL_SOCKET, SO_ERROR, &error, &errorlen) == -1)
 
1021
        {
 
1022
          msg_error("getsockopt(SOL_SOCKET, SO_ERROR) failed for connecting socket",
 
1023
                    evt_tag_int("fd", self->fd),
 
1024
                    evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
 
1025
                    evt_tag_errno(EVT_TAG_OSERROR, errno),
 
1026
                    evt_tag_int("time_reopen", self->time_reopen),
 
1027
                    NULL);
 
1028
          goto error_reconnect;
 
1029
        }
 
1030
      if (error)
 
1031
        {
 
1032
          msg_error("Syslog connection failed",
 
1033
                    evt_tag_int("fd", self->fd),
 
1034
                    evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
 
1035
                    evt_tag_errno(EVT_TAG_OSERROR, error),
 
1036
                    evt_tag_int("time_reopen", self->time_reopen),
 
1037
                    NULL);
 
1038
          goto error_reconnect;
 
1039
        }
 
1040
    }
 
1041
  msg_notice("Syslog connection established",
 
1042
              evt_tag_int("fd", self->fd),
 
1043
              evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
 
1044
              evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf1, sizeof(buf1), GSA_FULL)),
 
1045
              NULL);
 
1046
 
 
1047
 
 
1048
#if ENABLE_SSL
 
1049
  if (self->tls_context)
 
1050
    {
 
1051
      TLSSession *tls_session;
 
1052
 
 
1053
      tls_session = tls_context_setup_session(self->tls_context);
 
1054
      if (!tls_session)
 
1055
        {
 
1056
          goto error_reconnect;
 
1057
        }
 
1058
 
 
1059
      tls_session_set_verify(tls_session, afsocket_dd_tls_verify_callback, self, NULL);
 
1060
      transport = log_transport_tls_new(tls_session, self->fd, transport_flags);
 
1061
    }
 
1062
  else
 
1063
#endif
 
1064
    transport = log_transport_plain_new(self->fd, transport_flags);
 
1065
 
 
1066
  if (self->flags & AFSOCKET_SYSLOG_PROTOCOL)
 
1067
    {
 
1068
      if (self->flags & AFSOCKET_STREAM)
 
1069
        proto = log_proto_framed_client_new(transport);
 
1070
      else
 
1071
        proto = log_proto_text_client_new(transport);
 
1072
    }
 
1073
  else
 
1074
    {
 
1075
      proto = log_proto_text_client_new(transport);
 
1076
    }
 
1077
 
 
1078
  log_writer_reopen(self->writer, proto);
 
1079
  return TRUE;
 
1080
 error_reconnect:
 
1081
  close(self->fd);
 
1082
  self->fd = -1;
 
1083
  afsocket_dd_start_reconnect_timer(self);
 
1084
  return FALSE;
 
1085
}
 
1086
 
 
1087
static gboolean
 
1088
afsocket_dd_start_connect(AFSocketDestDriver *self)
 
1089
{
 
1090
  int sock, rc;
 
1091
  gchar buf1[MAX_SOCKADDR_STRING], buf2[MAX_SOCKADDR_STRING];
 
1092
 
 
1093
  main_loop_assert_main_thread();
 
1094
  if (!afsocket_open_socket(self->bind_addr, !!(self->flags & AFSOCKET_STREAM), &sock))
 
1095
    {
 
1096
      return FALSE;
 
1097
    }
 
1098
 
 
1099
  if (self->setup_socket && !self->setup_socket(self, sock))
 
1100
    {
 
1101
      close(sock);
 
1102
      return FALSE;
 
1103
    }
 
1104
 
 
1105
  rc = g_connect(sock, self->dest_addr);
 
1106
  if (rc == G_IO_STATUS_NORMAL)
 
1107
    {
 
1108
      self->fd = sock;
 
1109
      afsocket_dd_connected(self);
 
1110
    }
 
1111
  else if (rc == G_IO_STATUS_ERROR && errno == EINPROGRESS)
 
1112
    {
 
1113
      /* we must wait until connect succeeds */
 
1114
 
 
1115
      self->fd = sock;
 
1116
      afsocket_dd_start_watches(self);
 
1117
    }
 
1118
  else
 
1119
    {
 
1120
      /* error establishing connection */
 
1121
      msg_error("Connection failed",
 
1122
                evt_tag_int("fd", sock),
 
1123
                evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf2, sizeof(buf2), GSA_FULL)),
 
1124
                evt_tag_str("local", g_sockaddr_format(self->bind_addr, buf1, sizeof(buf1), GSA_FULL)),
 
1125
                evt_tag_errno(EVT_TAG_OSERROR, errno),
 
1126
                NULL);
 
1127
      close(sock);
 
1128
      return FALSE;
 
1129
    }
 
1130
 
 
1131
  return TRUE;
 
1132
}
 
1133
 
 
1134
static void
 
1135
afsocket_dd_reconnect(AFSocketDestDriver *self)
 
1136
{
 
1137
  if (!afsocket_dd_start_connect(self))
 
1138
    {
 
1139
      msg_error("Initiating connection failed, reconnecting",
 
1140
                evt_tag_int("time_reopen", self->time_reopen),
 
1141
                NULL);
 
1142
      afsocket_dd_start_reconnect_timer(self);
 
1143
    }
 
1144
}
 
1145
 
 
1146
gboolean
 
1147
afsocket_dd_init(LogPipe *s)
 
1148
{
 
1149
  AFSocketDestDriver *self = (AFSocketDestDriver *) s;
 
1150
  GlobalConfig *cfg = log_pipe_get_config(s);
 
1151
 
 
1152
  if (!log_dest_driver_init_method(s))
 
1153
    return FALSE;
 
1154
 
 
1155
  if (!afsocket_dd_apply_transport(self))
 
1156
    return FALSE;
 
1157
 
 
1158
  /* these fields must be set up by apply_transport, so let's check if it indeed did */
 
1159
  g_assert(self->transport);
 
1160
  g_assert(self->bind_addr);
 
1161
  g_assert(self->dest_addr);
 
1162
  g_assert(self->hostname);
 
1163
  g_assert(self->dest_name);
 
1164
 
 
1165
  if (cfg)
 
1166
    {
 
1167
      self->time_reopen = cfg->time_reopen;
 
1168
    }
 
1169
 
 
1170
  log_writer_options_init(&self->writer_options, cfg, 0);
 
1171
  self->writer = cfg_persist_config_fetch(cfg, afsocket_dd_format_persist_name(self, FALSE));
 
1172
  if (!self->writer)
 
1173
    {
 
1174
      /* NOTE: we open our writer with no fd, so we can send messages down there
 
1175
       * even while the connection is not established */
 
1176
 
 
1177
      self->writer = log_writer_new(LW_FORMAT_PROTO |
 
1178
#if ENABLE_SSL
 
1179
                                    (((self->flags & AFSOCKET_STREAM) && !self->tls_context) ? LW_DETECT_EOF : 0) |
 
1180
#else
 
1181
                                    ((self->flags & AFSOCKET_STREAM) ? LW_DETECT_EOF : 0) |
 
1182
#endif
 
1183
                                    (self->flags & AFSOCKET_SYSLOG_PROTOCOL ? LW_SYSLOG_PROTOCOL : 0));
 
1184
 
 
1185
    }
 
1186
  log_writer_set_options((LogWriter *) self->writer, &self->super.super.super, &self->writer_options, 0, afsocket_dd_stats_source(self), self->super.super.id, afsocket_dd_stats_instance(self));
 
1187
  log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super, afsocket_dd_format_persist_name(self, TRUE)));
 
1188
 
 
1189
  log_pipe_init(self->writer, NULL);
 
1190
  log_pipe_append(&self->super.super.super, self->writer);
 
1191
 
 
1192
  if (!log_writer_opened((LogWriter *) self->writer))
 
1193
    afsocket_dd_reconnect(self);
 
1194
  return TRUE;
 
1195
}
 
1196
 
 
1197
gboolean
 
1198
afsocket_dd_deinit(LogPipe *s)
 
1199
{
 
1200
  AFSocketDestDriver *self = (AFSocketDestDriver *) s;
 
1201
  GlobalConfig *cfg = log_pipe_get_config(s);
 
1202
 
 
1203
  afsocket_dd_stop_watches(self);
 
1204
 
 
1205
  if (self->writer)
 
1206
    log_pipe_deinit(self->writer);
 
1207
 
 
1208
  if (self->flags & AFSOCKET_KEEP_ALIVE)
 
1209
    {
 
1210
      cfg_persist_config_add(cfg, afsocket_dd_format_persist_name(self, FALSE), self->writer, (GDestroyNotify) log_pipe_unref, FALSE);
 
1211
      self->writer = NULL;
 
1212
    }
 
1213
 
 
1214
  if (!log_dest_driver_deinit_method(s))
 
1215
    return FALSE;
 
1216
 
 
1217
  return TRUE;
 
1218
}
 
1219
 
 
1220
static void
 
1221
afsocket_dd_notify(LogPipe *s, LogPipe *sender, gint notify_code, gpointer user_data)
 
1222
{
 
1223
  AFSocketDestDriver *self = (AFSocketDestDriver *) s;
 
1224
  gchar buf[MAX_SOCKADDR_STRING];
 
1225
 
 
1226
  switch (notify_code)
 
1227
    {
 
1228
    case NC_CLOSE:
 
1229
    case NC_WRITE_ERROR:
 
1230
      log_writer_reopen(self->writer, NULL);
 
1231
 
 
1232
      msg_notice("Syslog connection broken",
 
1233
                 evt_tag_int("fd", self->fd),
 
1234
                 evt_tag_str("server", g_sockaddr_format(self->dest_addr, buf, sizeof(buf), GSA_FULL)),
 
1235
                 evt_tag_int("time_reopen", self->time_reopen),
 
1236
                 NULL);
 
1237
      afsocket_dd_start_reconnect_timer(self);
 
1238
      break;
 
1239
    }
 
1240
}
 
1241
 
 
1242
static gboolean
 
1243
afsocket_dd_setup_socket(AFSocketDestDriver *self, gint fd)
 
1244
{
 
1245
  return afsocket_setup_socket(fd, self->sock_options_ptr, AFSOCKET_DIR_SEND);
 
1246
}
 
1247
 
 
1248
void
 
1249
afsocket_dd_free(LogPipe *s)
 
1250
{
 
1251
  AFSocketDestDriver *self = (AFSocketDestDriver *) s;
 
1252
 
 
1253
  log_writer_options_destroy(&self->writer_options);
 
1254
  g_sockaddr_unref(self->bind_addr);
 
1255
  g_sockaddr_unref(self->dest_addr);
 
1256
  log_pipe_unref(self->writer);
 
1257
  g_free(self->hostname);
 
1258
  g_free(self->dest_name);
 
1259
  g_free(self->transport);
 
1260
  log_dest_driver_free(s);
 
1261
}
 
1262
 
 
1263
void
 
1264
afsocket_dd_init_instance(AFSocketDestDriver *self, SocketOptions *sock_options, gint family, const gchar *hostname, guint32 flags)
 
1265
{
 
1266
  log_dest_driver_init_instance(&self->super);
 
1267
 
 
1268
  log_writer_options_defaults(&self->writer_options);
 
1269
  self->super.super.super.init = afsocket_dd_init;
 
1270
  self->super.super.super.deinit = afsocket_dd_deinit;
 
1271
  /* NULL behaves as if log_msg_forward_msg was specified */
 
1272
  self->super.super.super.queue = NULL;
 
1273
  self->super.super.super.free_fn = afsocket_dd_free;
 
1274
  self->super.super.super.notify = afsocket_dd_notify;
 
1275
  self->setup_socket = afsocket_dd_setup_socket;
 
1276
  self->sock_options_ptr = sock_options;
 
1277
  self->address_family = family;
 
1278
  self->flags = flags  | AFSOCKET_KEEP_ALIVE;
 
1279
 
 
1280
  self->hostname = g_strdup(hostname);
 
1281
 
 
1282
  afsocket_dd_init_watches(self);
 
1283
}