← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/syslog-ng/oneiric

« back to all changes in this revision

Viewing changes to modules/afsocket/afinet.c

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2011-05-16 22:02:46 UTC
  • mfrom: (26.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20110516220246-nknmeu831n49bx1z
Tags: 3.2.4-1
* New upstream release, fixing infinite loop via PCRE and global. No CVE
  number yet, Vigil@nce id is 10648.
* Remove all patches, they were applied upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/afsocket/afinet.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 "afinet.h"
 
25
#include "messages.h"
 
26
#include "misc.h"
 
27
#include "gprocess.h"
 
28
 
 
29
#include <sys/types.h>
 
30
#include <sys/socket.h>
 
31
#include <arpa/inet.h>
 
32
#include <netdb.h>
 
33
#include <netinet/in.h>
 
34
#include <stdlib.h>
 
35
#include <string.h>
 
36
 
 
37
#ifndef SOL_IP
 
38
#define SOL_IP IPPROTO_IP
 
39
#endif
 
40
 
 
41
#ifndef SOL_IPV6
 
42
#define SOL_IPV6 IPPROTO_IPV6
 
43
#endif
 
44
 
 
45
 
 
46
static void
 
47
afinet_set_port(GSockAddr *addr, gchar *service, const gchar *proto)
 
48
{
 
49
  if (addr)
 
50
    {
 
51
      gchar *end;
 
52
      gint port;
 
53
 
 
54
      /* check if service is numeric */
 
55
      port = strtol(service, &end, 10);
 
56
      if ((*end != 0))
 
57
        {
 
58
          struct servent *se;
 
59
 
 
60
          /* service is not numeric, check if it's a service in /etc/services */
 
61
          se = getservbyname(service, proto);
 
62
          if (se)
 
63
            {
 
64
              port = ntohs(se->s_port);
 
65
            }
 
66
          else
 
67
            {
 
68
              msg_error("Error finding port number, falling back to default",
 
69
                        evt_tag_printf("service", "%s/%s", proto, service),
 
70
                        NULL);
 
71
              return;
 
72
            }
 
73
        }
 
74
 
 
75
      switch (addr->sa.sa_family)
 
76
        {
 
77
        case AF_INET:
 
78
          g_sockaddr_inet_set_port(addr, port);
 
79
          break;
 
80
#if ENABLE_IPV6
 
81
        case AF_INET6:
 
82
          g_sockaddr_inet6_set_port(addr, port);
 
83
          break;
 
84
#endif
 
85
        default:
 
86
          g_assert_not_reached();
 
87
          break;
 
88
        }
 
89
    }
 
90
}
 
91
 
 
92
 
 
93
static gboolean
 
94
afinet_setup_socket(gint fd, GSockAddr *addr, InetSocketOptions *sock_options, AFSocketDirection dir)
 
95
{
 
96
  gint off = 0;
 
97
 
 
98
  if (!afsocket_setup_socket(fd, &sock_options->super, dir))
 
99
    return FALSE;
 
100
 
 
101
  switch (addr->sa.sa_family)
 
102
    {
 
103
    case AF_INET:
 
104
      {
 
105
        struct ip_mreq mreq;
 
106
 
 
107
        if (IN_MULTICAST(ntohl(g_sockaddr_inet_get_address(addr).s_addr)))
 
108
          {
 
109
            if (dir & AFSOCKET_DIR_RECV)
 
110
              {
 
111
                memset(&mreq, 0, sizeof(mreq));
 
112
                mreq.imr_multiaddr = g_sockaddr_inet_get_address(addr);
 
113
                mreq.imr_interface.s_addr = INADDR_ANY;
 
114
                setsockopt(fd, SOL_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
 
115
                setsockopt(fd, SOL_IP, IP_MULTICAST_LOOP, &off, sizeof(off));
 
116
              }
 
117
            if (dir & AFSOCKET_DIR_SEND)
 
118
              {
 
119
                if (sock_options->ttl)
 
120
                  setsockopt(fd, SOL_IP, IP_MULTICAST_TTL, &sock_options->ttl, sizeof(sock_options->ttl));
 
121
              }
 
122
 
 
123
          }
 
124
        else
 
125
          {
 
126
            if (sock_options->ttl && (dir & AFSOCKET_DIR_SEND))
 
127
              setsockopt(fd, SOL_IP, IP_TTL, &sock_options->ttl, sizeof(sock_options->ttl));
 
128
          }
 
129
        if (sock_options->tos && (dir & AFSOCKET_DIR_SEND))
 
130
          setsockopt(fd, SOL_IP, IP_TOS, &sock_options->tos, sizeof(sock_options->tos));
 
131
 
 
132
        break;
 
133
      }
 
134
#if ENABLE_IPV6
 
135
    case AF_INET6:
 
136
      {
 
137
        struct ipv6_mreq mreq6;
 
138
 
 
139
        if (IN6_IS_ADDR_MULTICAST(&g_sockaddr_inet6_get_sa(addr)->sin6_addr))
 
140
          {
 
141
            if (dir & AFSOCKET_DIR_RECV)
 
142
              {
 
143
                memset(&mreq6, 0, sizeof(mreq6));
 
144
                mreq6.ipv6mr_multiaddr = *g_sockaddr_inet6_get_address(addr);
 
145
                mreq6.ipv6mr_interface = 0;
 
146
                setsockopt(fd, SOL_IPV6, IPV6_JOIN_GROUP, &mreq6, sizeof(mreq6));
 
147
                setsockopt(fd, SOL_IPV6, IPV6_MULTICAST_LOOP, &off, sizeof(off));
 
148
              }
 
149
            if (dir & AFSOCKET_DIR_SEND)
 
150
              {
 
151
                if (sock_options->ttl)
 
152
                  setsockopt(fd, SOL_IPV6, IPV6_MULTICAST_HOPS, &sock_options->ttl, sizeof(sock_options->ttl));
 
153
              }
 
154
          }
 
155
        else
 
156
          {
 
157
            if (sock_options->ttl && (dir & AFSOCKET_DIR_SEND))
 
158
              setsockopt(fd, SOL_IPV6, IPV6_UNICAST_HOPS, &sock_options->ttl, sizeof(sock_options->ttl));
 
159
          }
 
160
        break;
 
161
      }
 
162
#endif
 
163
    }
 
164
  return TRUE;
 
165
}
 
166
 
 
167
void
 
168
afinet_sd_set_localport(LogDriver *s, gchar *service, const gchar *proto)
 
169
{
 
170
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
171
 
 
172
  afinet_set_port(self->bind_addr, service, proto);
 
173
}
 
174
 
 
175
void
 
176
afinet_sd_set_localip(LogDriver *s, gchar *ip)
 
177
{
 
178
  AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
 
179
 
 
180
  resolve_hostname(&self->bind_addr, ip);
 
181
}
 
182
 
 
183
static gboolean
 
184
afinet_sd_setup_socket(AFSocketSourceDriver *s, gint fd)
 
185
{
 
186
  return afinet_setup_socket(fd, s->bind_addr, (InetSocketOptions *) s->sock_options_ptr, AFSOCKET_DIR_RECV);
 
187
}
 
188
 
 
189
void
 
190
afinet_sd_set_transport(LogDriver *s, const gchar *transport)
 
191
{
 
192
  AFInetSourceDriver *self = (AFInetSourceDriver *) s;
 
193
 
 
194
  if (self->super.transport)
 
195
    g_free(self->super.transport);
 
196
  self->super.transport = g_strdup(transport);
 
197
  if (strcasecmp(transport, "udp") == 0)
 
198
    {
 
199
      self->super.flags = (self->super.flags & ~0x0003) | AFSOCKET_DGRAM;
 
200
    }
 
201
  else if (strcasecmp(transport, "tcp") == 0)
 
202
    {
 
203
      self->super.flags = (self->super.flags & ~0x0003) | AFSOCKET_STREAM;
 
204
    }
 
205
  else if (strcasecmp(transport, "tls") == 0)
 
206
    {
 
207
      self->super.flags = (self->super.flags & ~0x0003) | AFSOCKET_STREAM | AFSOCKET_REQUIRE_TLS;
 
208
    }
 
209
  else
 
210
    {
 
211
      msg_error("Unknown syslog transport specified, please use one of udp, tcp, or tls",
 
212
                evt_tag_str("transport", transport),
 
213
                NULL);
 
214
    }
 
215
}
 
216
 
 
217
LogDriver *
 
218
afinet_sd_new(gint af, gchar *host, gint port, guint flags)
 
219
{
 
220
  AFInetSourceDriver *self = g_new0(AFInetSourceDriver, 1);
 
221
 
 
222
  afsocket_sd_init_instance(&self->super, &self->sock_options.super, flags);
 
223
  if (self->super.flags & AFSOCKET_DGRAM)
 
224
    self->super.transport = g_strdup("udp");
 
225
  else if (self->super.flags & AFSOCKET_STREAM)
 
226
    self->super.transport = g_strdup("tcp");
 
227
  if (af == AF_INET)
 
228
    {
 
229
      self->super.bind_addr = g_sockaddr_inet_new("0.0.0.0", port);
 
230
      if (!host)
 
231
        host = "0.0.0.0";
 
232
    }
 
233
  else
 
234
    {
 
235
#if ENABLE_IPV6
 
236
      self->super.bind_addr = g_sockaddr_inet6_new("::", port);
 
237
      if (!host)
 
238
        host = "::";
 
239
#else
 
240
      g_assert_not_reached();
 
241
#endif
 
242
    }
 
243
  resolve_hostname(&self->super.bind_addr, host);
 
244
  self->super.setup_socket = afinet_sd_setup_socket;
 
245
 
 
246
  return &self->super.super;
 
247
}
 
248
 
 
249
/* afinet destination */
 
250
 
 
251
void
 
252
afinet_dd_set_localport(LogDriver *s, gchar *service, const gchar *proto)
 
253
{
 
254
  AFInetDestDriver *self = (AFInetDestDriver *) s;
 
255
 
 
256
  afinet_set_port(self->super.bind_addr, service, proto);
 
257
}
 
258
 
 
259
void
 
260
afinet_dd_set_destport(LogDriver *s, gchar *service, const gchar *proto)
 
261
{
 
262
  AFInetDestDriver *self = (AFInetDestDriver *) s;
 
263
 
 
264
  afinet_set_port(self->super.dest_addr, service, proto);
 
265
 
 
266
  g_free(self->super.dest_name);
 
267
  self->super.dest_name = g_strdup_printf("%s:%d", self->super.hostname,
 
268
                  g_sockaddr_inet_check(self->super.dest_addr) ? g_sockaddr_inet_get_port(self->super.dest_addr)
 
269
#if ENABLE_IPV6
 
270
                                                               : g_sockaddr_inet6_get_port(self->super.dest_addr)
 
271
#else
 
272
                                                               : 0
 
273
#endif
 
274
  );
 
275
}
 
276
 
 
277
void
 
278
afinet_dd_set_localip(LogDriver *s, gchar *ip)
 
279
{
 
280
  AFInetDestDriver *self = (AFInetDestDriver *) s;
 
281
 
 
282
  resolve_hostname(&self->super.bind_addr, ip);
 
283
}
 
284
 
 
285
void
 
286
afinet_dd_set_spoof_source(LogDriver *s, gboolean enable)
 
287
{
 
288
#if ENABLE_SPOOF_SOURCE
 
289
  AFInetDestDriver *self = (AFInetDestDriver *) s;
 
290
 
 
291
  self->spoof_source = (self->super.flags & AFSOCKET_DGRAM) && enable;
 
292
#else
 
293
  msg_error("Error enabling spoof-source, you need to compile syslog-ng with --enable-spoof-source", NULL);
 
294
#endif
 
295
}
 
296
 
 
297
void
 
298
afinet_dd_set_transport(LogDriver *s, const gchar *transport)
 
299
{
 
300
  AFInetDestDriver *self = (AFInetDestDriver *) s;
 
301
 
 
302
  if (self->super.transport)
 
303
    g_free(self->super.transport);
 
304
  self->super.transport = g_strdup(transport);
 
305
  if (strcasecmp(transport, "udp") == 0)
 
306
    {
 
307
      self->super.flags = (self->super.flags & ~0x0003) | AFSOCKET_DGRAM;
 
308
    }
 
309
  else if (strcasecmp(transport, "tcp") == 0)
 
310
    {
 
311
      self->super.flags = (self->super.flags & ~0x0003) | AFSOCKET_STREAM;
 
312
    }
 
313
  else if (strcasecmp(transport, "tls") == 0)
 
314
    {
 
315
      self->super.flags = (self->super.flags & ~0x0003) | AFSOCKET_STREAM | AFSOCKET_REQUIRE_TLS;
 
316
    }
 
317
  else
 
318
    {
 
319
      msg_error("Unknown syslog transport specified, please use one of udp, tcp, or tls",
 
320
                evt_tag_str("transport", transport),
 
321
                NULL);
 
322
    }
 
323
}
 
324
 
 
325
static gboolean
 
326
afinet_dd_setup_socket(AFSocketDestDriver *s, gint fd)
 
327
{
 
328
  AFInetDestDriver *self = (AFInetDestDriver *) s;
 
329
 
 
330
  if (!resolve_hostname(&self->super.dest_addr, self->super.hostname))
 
331
    return FALSE;
 
332
 
 
333
  return afinet_setup_socket(fd, self->super.dest_addr, (InetSocketOptions *) s->sock_options_ptr, AFSOCKET_DIR_SEND);
 
334
}
 
335
 
 
336
static gboolean
 
337
afinet_dd_init(LogPipe *s)
 
338
{
 
339
  AFInetDestDriver *self G_GNUC_UNUSED = (AFInetDestDriver *) s;
 
340
  gboolean success;
 
341
 
 
342
  success = afsocket_dd_init(s);
 
343
#if ENABLE_SPOOF_SOURCE
 
344
  if (success)
 
345
    {
 
346
      if (self->spoof_source && !self->lnet_ctx)
 
347
        {
 
348
          gchar error[LIBNET_ERRBUF_SIZE];
 
349
          cap_t saved_caps;
 
350
 
 
351
          saved_caps = g_process_cap_save();
 
352
          g_process_cap_modify(CAP_NET_RAW, TRUE);
 
353
          self->lnet_ctx = libnet_init(self->super.dest_addr->sa.sa_family == AF_INET ? LIBNET_RAW4 : LIBNET_RAW6, NULL, error);
 
354
          g_process_cap_restore(saved_caps);
 
355
          if (!self->lnet_ctx)
 
356
            {
 
357
              msg_error("Error initializing raw socket, spoof-source support disabled",
 
358
                        evt_tag_str("error", NULL),
 
359
                        NULL);
 
360
            }
 
361
        }
 
362
    }
 
363
#endif
 
364
 
 
365
  return success;
 
366
}
 
367
 
 
368
#if ENABLE_SPOOF_SOURCE
 
369
static gboolean
 
370
afinet_dd_construct_ipv4_packet(AFInetDestDriver *self, LogMessage *msg, GString *msg_line)
 
371
{
 
372
  libnet_ptag_t ip, udp;
 
373
  struct sockaddr_in *src, *dst;
 
374
 
 
375
  if (msg->saddr->sa.sa_family != AF_INET)
 
376
    return FALSE;
 
377
 
 
378
  src = (struct sockaddr_in *) &msg->saddr->sa;
 
379
  dst = (struct sockaddr_in *) &self->super.dest_addr->sa;
 
380
 
 
381
  libnet_clear_packet(self->lnet_ctx);
 
382
 
 
383
  udp = libnet_build_udp(ntohs(src->sin_port),
 
384
                         ntohs(dst->sin_port),
 
385
                         LIBNET_UDP_H + msg_line->len,
 
386
                         0,
 
387
                         (guchar *) msg_line->str,
 
388
                         msg_line->len,
 
389
                         self->lnet_ctx,
 
390
                         0);
 
391
  if (udp == -1)
 
392
    return FALSE;
 
393
 
 
394
  ip = libnet_build_ipv4(LIBNET_IPV4_H + msg_line->len + LIBNET_UDP_H,
 
395
                         IPTOS_LOWDELAY,         /* IP tos */
 
396
                         0,                      /* IP ID */
 
397
                         0,                      /* frag stuff */
 
398
                         64,                     /* TTL */
 
399
                         IPPROTO_UDP,            /* transport protocol */
 
400
                         0,
 
401
                         src->sin_addr.s_addr,   /* source IP */
 
402
                         dst->sin_addr.s_addr,   /* destination IP */
 
403
                         NULL,                   /* payload (none) */
 
404
                         0,                      /* payload length */
 
405
                         self->lnet_ctx,
 
406
                         0);
 
407
  if (ip == -1)
 
408
    return FALSE;
 
409
 
 
410
  return TRUE;
 
411
}
 
412
 
 
413
#if ENABLE_IPV6
 
414
static gboolean
 
415
afinet_dd_construct_ipv6_packet(AFInetDestDriver *self, LogMessage *msg, GString *msg_line)
 
416
{
 
417
  libnet_ptag_t ip, udp;
 
418
  struct sockaddr_in *src4;
 
419
  struct sockaddr_in6 src, *dst;
 
420
  struct libnet_in6_addr ln_src, ln_dst;
 
421
 
 
422
  switch (msg->saddr->sa.sa_family)
 
423
    {
 
424
    case AF_INET:
 
425
      src4 = (struct sockaddr_in *) &msg->saddr->sa;
 
426
      memset(&src, 0, sizeof(src));
 
427
      src.sin6_family = AF_INET6;
 
428
      src.sin6_port = src4->sin_port;
 
429
      ((guint32 *) &src.sin6_addr)[0] = 0;
 
430
      ((guint32 *) &src.sin6_addr)[1] = 0;
 
431
      ((guint32 *) &src.sin6_addr)[2] = htonl(0xffff);
 
432
      ((guint32 *) &src.sin6_addr)[3] = src4->sin_addr.s_addr;
 
433
      break;
 
434
    case AF_INET6:
 
435
      src = *((struct sockaddr_in6 *) &msg->saddr->sa);
 
436
      break;
 
437
    default:
 
438
      g_assert_not_reached();
 
439
      break;
 
440
    }
 
441
 
 
442
  dst = (struct sockaddr_in6 *) &self->super.dest_addr->sa;
 
443
 
 
444
  libnet_clear_packet(self->lnet_ctx);
 
445
 
 
446
  udp = libnet_build_udp(ntohs(src.sin6_port),
 
447
                         ntohs(dst->sin6_port),
 
448
                         LIBNET_UDP_H + msg_line->len,
 
449
                         0,
 
450
                         (guchar *) msg_line->str,
 
451
                         msg_line->len,
 
452
                         self->lnet_ctx,
 
453
                         0);
 
454
  if (udp == -1)
 
455
    return FALSE;
 
456
 
 
457
  /* There seems to be a bug in libnet 1.1.2 that is triggered when
 
458
   * checksumming UDP6 packets. This is a workaround below. */
 
459
 
 
460
  libnet_toggle_checksum(self->lnet_ctx, udp, LIBNET_OFF);
 
461
 
 
462
  memcpy(&ln_src, &src.sin6_addr, sizeof(ln_src));
 
463
  memcpy(&ln_dst, &dst->sin6_addr, sizeof(ln_dst));
 
464
  ip = libnet_build_ipv6(0, 0,
 
465
                         LIBNET_UDP_H + msg_line->len,
 
466
                         IPPROTO_UDP,            /* IPv6 next header */
 
467
                         64,                     /* hop limit */
 
468
                         ln_src, ln_dst,
 
469
                         NULL, 0,                /* payload and its length */
 
470
                         self->lnet_ctx,
 
471
                         0);
 
472
 
 
473
  if (ip == -1)
 
474
    return FALSE;
 
475
 
 
476
  return TRUE;
 
477
}
 
478
#endif
 
479
 
 
480
#endif
 
481
 
 
482
static void
 
483
afinet_dd_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options)
 
484
{
 
485
#if ENABLE_SPOOF_SOURCE
 
486
  AFInetDestDriver *self = (AFInetDestDriver *) s;
 
487
 
 
488
  if (self->spoof_source && self->lnet_ctx && msg->saddr && (msg->saddr->sa.sa_family == AF_INET || msg->saddr->sa.sa_family == AF_INET6))
 
489
    {
 
490
      gboolean success = FALSE;
 
491
      GString *msg_line = g_string_sized_new(256);
 
492
 
 
493
      g_assert((self->super.flags & AFSOCKET_DGRAM) != 0);
 
494
 
 
495
      log_writer_format_log((LogWriter *) self->super.writer, msg, msg_line);
 
496
 
 
497
      switch (self->super.dest_addr->sa.sa_family)
 
498
        {
 
499
        case AF_INET:
 
500
          success = afinet_dd_construct_ipv4_packet(self, msg, msg_line);
 
501
          break;
 
502
#if ENABLE_IPV6
 
503
        case AF_INET6:
 
504
          success = afinet_dd_construct_ipv6_packet(self, msg, msg_line);
 
505
          break;
 
506
#endif
 
507
        default:
 
508
          g_assert_not_reached();
 
509
        }
 
510
      if (success)
 
511
        {
 
512
          if (libnet_write(self->lnet_ctx) >= 0)
 
513
            {
 
514
              /* we have finished processing msg */
 
515
              log_msg_ack(msg, path_options);
 
516
              log_msg_unref(msg);
 
517
              g_string_free(msg_line, TRUE);
 
518
 
 
519
              return;
 
520
            }
 
521
          else
 
522
            {
 
523
              msg_error("Error sending raw frame",
 
524
                        evt_tag_str("error", libnet_geterror(self->lnet_ctx)),
 
525
                        NULL);
 
526
            }
 
527
        }
 
528
      g_string_free(msg_line, TRUE);
 
529
    }
 
530
#endif
 
531
  log_pipe_forward_msg(s, msg, path_options);
 
532
}
 
533
 
 
534
void
 
535
afinet_dd_free(LogPipe *s)
 
536
{
 
537
  afsocket_dd_free(s);
 
538
}
 
539
 
 
540
 
 
541
LogDriver *
 
542
afinet_dd_new(gint af, gchar *host, gint port, guint flags)
 
543
{
 
544
  AFInetDestDriver *self = g_new0(AFInetDestDriver, 1);
 
545
 
 
546
  afsocket_dd_init_instance(&self->super, &self->sock_options.super, flags, g_strdup(host), g_strdup_printf("%s:%d", host, port));
 
547
  if (self->super.flags & AFSOCKET_DGRAM)
 
548
    self->super.transport = g_strdup("udp");
 
549
  else if (self->super.flags & AFSOCKET_STREAM)
 
550
    self->super.transport = g_strdup("tcp");
 
551
  self->super.super.super.init = afinet_dd_init;
 
552
  self->super.super.super.queue = afinet_dd_queue;
 
553
  self->super.super.super.free_fn = afinet_dd_free;
 
554
  if (af == AF_INET)
 
555
    {
 
556
      self->super.bind_addr = g_sockaddr_inet_new("0.0.0.0", 0);
 
557
      self->super.dest_addr = g_sockaddr_inet_new("0.0.0.0", port);
 
558
    }
 
559
  else
 
560
    {
 
561
#if ENABLE_IPV6
 
562
      self->super.bind_addr = g_sockaddr_inet6_new("::", 0);
 
563
      self->super.dest_addr = g_sockaddr_inet6_new("::", port);
 
564
#else
 
565
      g_assert_not_reached();
 
566
#endif
 
567
    }
 
568
  self->super.setup_socket = afinet_dd_setup_socket;
 
569
  return &self->super.super;
 
570
}