udp.c 14.3 KB
Newer Older
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
1
2
3
/*****************************************************************************
 * udp.c:
 *****************************************************************************
4
 * Copyright (C) 2004-2006 the VideoLAN team
5
6
 * Copyright © 2006 Rémi Denis-Courmont
 *
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 * $Id$
 *
 * Authors: Laurent Aimar <fenrir@videolan.org>
 *          Rémi Denis-Courmont <rem # videolan.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
dionoea's avatar
dionoea committed
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
25
26
27
28
29
30
31
32
33
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
#include <stdlib.h>
#include <vlc/vlc.h>

#include <errno.h>
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
34
#include <assert.h>
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
35
36
37
38
39
40
41

#ifdef HAVE_SYS_TIME_H
#    include <sys/time.h>
#endif

#include "network.h"

42
43
44
45
46
47
48
#ifdef WIN32
#   if defined(UNDER_CE)
#       undef IP_MULTICAST_TTL
#       define IP_MULTICAST_TTL 3
#       undef IP_ADD_MEMBERSHIP
#       define IP_ADD_MEMBERSHIP 5
#   endif
49
#   define EAFNOSUPPORT WSAEAFNOSUPPORT
50
51
52
#   define if_nametoindex( str ) atoi( str )
#else
#   include <unistd.h>
Eric Petit's avatar
Eric Petit committed
53
54
55
#   ifdef HAVE_NET_IF_H
#       include <net/if.h>
#   endif
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
56
#endif
57
58
59
60
61
62
63
64
65

#ifndef SOL_IP
# define SOL_IP IPPROTO_IP
#endif
#ifndef SOL_IPV6
# define SOL_IPV6 IPPROTO_IPV6
#endif
#ifndef IPPROTO_IPV6
# define IPPROTO_IPV6 41
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
66
67
68
69
70
#endif

extern int net_Socket( vlc_object_t *p_this, int i_family, int i_socktype,
                       int i_protocol );

71

72
73
static int net_SetMcastHopLimit( vlc_object_t *p_this,
                                 int fd, int family, int hlim )
74
{
75
#ifndef SYS_BEOS
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
    int proto, cmd;

    /* There is some confusion in the world whether IP_MULTICAST_TTL 
     * takes a byte or an int as an argument.
     * BSD seems to indicate byte so we are going with that and use
     * int as a fallback to be safe */
    switch( family )
    {
        case AF_INET:
            proto = SOL_IP;
            cmd = IP_MULTICAST_TTL;
            break;

#ifdef IPV6_MULTICAST_HOPS
        case AF_INET6:
            proto = SOL_IPV6;
            cmd = IPV6_MULTICAST_HOPS;
            break;
#endif

        default:
97
98
            msg_Warn( p_this, "%s", strerror( EAFNOSUPPORT ) );
            return VLC_EGENERIC;
99
100
101
102
103
104
105
106
    }

    if( setsockopt( fd, proto, cmd, &hlim, sizeof( hlim ) ) < 0 )
    {
        /* BSD compatibility */
        unsigned char buf;

        buf = (unsigned char)(( hlim > 255 ) ? 255 : hlim);
107
108
        if( setsockopt( fd, proto, cmd, &buf, sizeof( buf ) ) )
            return VLC_EGENERIC;
109
    }
110
111
#endif
    return VLC_SUCCESS;
112
113
114
}


115
static int net_SetMcastOutIface (int fd, int family, int scope)
116
{
117
    switch (family)
118
    {
119
120
121
122
123
124
125
#ifdef IPV6_MULTICAST_IF
        case AF_INET6:
            return setsockopt (fd, SOL_IPV6, IPV6_MULTICAST_IF,
                               &scope, sizeof (scope));
#endif

#ifdef __linux__
126
127
        case AF_INET:
        {
128
            struct ip_mreqn req = { .imr_ifindex = scope };
129

130
131
            return setsockopt (fd, SOL_IP, IP_MULTICAST_IF, &req,
                               sizeof (req));
132
        }
133
134
#endif
    }
135

136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
    errno = EAFNOSUPPORT;
    return -1;
}


static inline int net_SetMcastOutIPv4 (int fd, struct in_addr ipv4)
{
#ifdef IP_MULTICAST_IF
    return setsockopt( fd, SOL_IP, IP_MULTICAST_IF, &ipv4, sizeof (ipv4));
#else
    errno = EAFNOSUPPORT;
    return -1;
#endif
}


static int net_SetMcastOut (vlc_object_t *p_this, int fd, int family,
                            const char *iface, const char *addr)
{
    if (iface != NULL)
    {
        int scope = if_nametoindex (iface);
        if (scope == 0)
159
        {
160
161
162
            msg_Err (p_this, "%s: invalid interface for multicast", iface);
            return -1;
        }
163

164
165
        if (net_SetMcastOutIface (fd, family, scope) == 0)
            return 0;
166

167
168
169
170
171
172
173
174
175
        msg_Err (p_this, "%s: %s", iface, net_strerror (net_errno));
    }

    if (addr != NULL)
    {
        if (family == AF_INET)
        {
            struct in_addr ipv4;
            if (inet_pton (AF_INET, addr, &ipv4) <= 0)
176
            {
177
178
179
                msg_Err (p_this, "%s: invalid IPv4 address for multicast",
                         addr);
                return -1;
180
181
            }

182
183
184
185
186
            if (net_SetMcastOutIPv4 (fd, ipv4) == 0)
                return 0;

            msg_Err (p_this, "%s: %s", addr, net_strerror (net_errno));
        }
187
188
    }

189
    return -1;
190
191
}

192

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
int net_Subscribe (vlc_object_t *obj, int fd, const struct sockaddr *addr,
                   socklen_t addrlen)
{
    switch (addr->sa_family)
    {
#ifdef IP_ADD_MEMBERSHIP
        case AF_INET:
        {
            const struct sockaddr_in *v4 = (const struct sockaddr_in *)addr;
            if (addrlen < sizeof (*v4))
                return -1;

            struct ip_mreq imr;
            memset (&imr, 0, sizeof (imr));
            memcpy (&imr.imr_multiaddr, &v4->sin_addr, 4);

            /* FIXME: should use a different option for in and out */
            char *iif = config_GetPsz (obj, "miface-addr");
            if (iif != NULL)
            {
                if ((iif[0] != '\0') &&
                    (inet_pton (AF_INET, iif, &imr.imr_interface) <= 0))
                {
                    msg_Err (obj, "invalid multicast interface address %s",
                             iif);
                    free (iif);
                    return -1;
                }
                free (iif);
            }

            msg_Dbg (obj, "IP_ADD_MEMBERSHIP multicast request");

            if (setsockopt (fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imr,
                            sizeof (imr)))
            {
                msg_Err (obj, "cannot join IPv4 multicast group (%s)",
                         net_strerror (net_errno));
                return -1;
            }
            return 0;
        }
#endif

#ifdef IPV6_JOIN_GROUP
        case AF_INET6:
        {
            const struct sockaddr_in6 *v6 = (const struct sockaddr_in6 *)addr;
            if (addrlen < sizeof (*v6))
                return -1;

            struct ipv6_mreq imr;
            memset (&imr, 0, sizeof (imr));
            imr.ipv6mr_interface = v6->sin6_scope_id;
            memcpy (&imr.ipv6mr_multiaddr, &v6->sin6_addr, 16);

249
250
            msg_Dbg (obj, "IPV6_JOIN_GROUP multicast request");

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
            if (setsockopt (fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, &imr,
                            sizeof (imr)))
            {
                msg_Err (obj, "cannot join IPv6 multicast group (%s)",
                         net_strerror (net_errno));
                return -1;
            }

            return 0;
        }
#endif
    }

    msg_Err (obj, "Multicast not supported");
    return -1;
}


269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
int net_SetDSCP( int fd, uint8_t dscp )
{
    struct sockaddr_storage addr;
    if( getsockname( fd, (struct sockaddr *)&addr, &(socklen_t){ sizeof (addr) }) )
        return -1;

    int level, cmd;

    switch( addr.ss_family )
    {
#ifdef IPV6_TCLASS
        case AF_INET6:
            level = SOL_IPV6;
            cmd = IPV6_TCLASS;
            break;
#endif

        case AF_INET:
            level = SOL_IP;
            cmd = IP_TOS;
            break;

        default:
#ifdef ENOPROTOOPT
            errno = ENOPROTOOPT;
#endif
            return -1;
    }

    return setsockopt( fd, level, cmd, &(int){ dscp }, sizeof (int));
}


Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
302
303
304
305
306
307
308
/*****************************************************************************
 * __net_ConnectUDP:
 *****************************************************************************
 * Open a UDP socket to send data to a defined destination, with an optional
 * hop limit.
 *****************************************************************************/
int __net_ConnectUDP( vlc_object_t *p_this, const char *psz_host, int i_port,
309
                      int i_hlim )
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
310
311
312
313
314
315
316
317
{
    struct addrinfo hints, *res, *ptr;
    int             i_val, i_handle = -1;
    vlc_bool_t      b_unreach = VLC_FALSE;

    if( i_port == 0 )
        i_port = 1234; /* historical VLC thing */

318
    if( i_hlim < 1 )
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
319
        i_hlim = var_CreateGetInteger( p_this, "ttl" );
320

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
    memset( &hints, 0, sizeof( hints ) );
    hints.ai_socktype = SOCK_DGRAM;

    msg_Dbg( p_this, "net: connecting to %s port %d", psz_host, i_port );

    i_val = vlc_getaddrinfo( p_this, psz_host, i_port, &hints, &res );
    if( i_val )
    {
        msg_Err( p_this, "cannot resolve %s port %d : %s", psz_host, i_port,
                 vlc_gai_strerror( i_val ) );
        return -1;
    }

    for( ptr = res; ptr != NULL; ptr = ptr->ai_next )
    {
336
337
338
339
        char *str;
        int fd = net_Socket (p_this, ptr->ai_family, ptr->ai_socktype,
                             ptr->ai_protocol);
        if (fd == -1)
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
340
            continue;
341

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
342
#if !defined( SYS_BEOS )
343
344
345
346
347
348
349
        /* Increase the receive buffer size to 1/2MB (8Mb/s during 1/2s)
        * to avoid packet loss caused by scheduling problems */
        setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &(int){ 0x80000 }, sizeof (int));
        setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &(int){ 0x80000 }, sizeof (int));

        /* Allow broadcast sending */
        setsockopt (fd, SOL_SOCKET, SO_BROADCAST, &(int){ 1 }, sizeof (int));
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
350
351
#endif

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
352
        if( i_hlim > 0 )
353
            net_SetMcastHopLimit( p_this, fd, ptr->ai_family, i_hlim );
354
355
356
357

        str = var_CreateGetString (p_this, "miface");
        if (str != NULL)
        {
358
359
            if (*str)
                net_SetMcastOut (p_this, fd, ptr->ai_family, str, NULL);
360
361
362
363
364
            free (str);
        }

        str = var_CreateGetString (p_this, "miface-addr");
        if (str != NULL)
365
        {
366
367
            if (*str)
                net_SetMcastOut (p_this, fd, ptr->ai_family, NULL, str);
368
            free (str);
369
        }
370

371
372
        net_SetDSCP (fd, var_CreateGetInteger (p_this, "dscp"));

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
        if( connect( fd, ptr->ai_addr, ptr->ai_addrlen ) == 0 )
        {
            /* success */
            i_handle = fd;
            break;
        }

#if defined( WIN32 ) || defined( UNDER_CE )
        if( WSAGetLastError () == WSAENETUNREACH )
#else
        if( errno == ENETUNREACH )
#endif
            b_unreach = VLC_TRUE;
        else
        {
            msg_Warn( p_this, "%s port %d : %s", psz_host, i_port,
                      strerror( errno ) );
            net_Close( fd );
            continue;
        }
    }

    vlc_freeaddrinfo( res );

    if( i_handle == -1 )
    {
        if( b_unreach )
            msg_Err( p_this, "Host %s port %d is unreachable", psz_host,
                     i_port );
        return -1;
    }

    return i_handle;
}

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
408

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
409
410
411
412
413
414
415
416
417
418
419
420
421
/*****************************************************************************
 * __net_OpenUDP:
 *****************************************************************************
 * Open a UDP connection and return a handle
 *****************************************************************************/
int __net_OpenUDP( vlc_object_t *p_this, const char *psz_bind, int i_bind,
                   const char *psz_server, int i_server )
{
    vlc_value_t      v4, v6;
    void            *private;
    network_socket_t sock;
    module_t         *p_network = NULL;

422
423
424
425
426
427
428
429
430
431
432
    if (((psz_bind == NULL) || (psz_bind[0] == '\0')) && (i_bind == 0))
        msg_Warn (p_this,
                  "Obsolete net_OpenUDP with no local endpoint; "
                  "Use net_ConnectUDP instead");

#if 0
    if (((psz_server == NULL) || (psz_server[0] == '\0')) && (i_server == 0))
        msg_Warn (p_this,
                  "Obsolete net_OpenUDP with no remote endpoint; "
                  "Use net_ListenUDP instead");
#endif
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497

    if( psz_server == NULL ) psz_server = "";
    if( psz_bind == NULL ) psz_bind = "";

    /* Prepare the network_socket_t structure */
    sock.psz_bind_addr   = psz_bind;
    sock.i_bind_port     = i_bind;
    sock.psz_server_addr = psz_server;
    sock.i_server_port   = i_server;
    sock.i_ttl           = 0;
    sock.v6only          = 0;
    sock.i_handle        = -1;

    msg_Dbg( p_this, "net: connecting to '[%s]:%d@[%s]:%d'",
             psz_server, i_server, psz_bind, i_bind );

    /* Check if we have force ipv4 or ipv6 */
    var_Create( p_this, "ipv4", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
    var_Get( p_this, "ipv4", &v4 );
    var_Create( p_this, "ipv6", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
    var_Get( p_this, "ipv6", &v6 );

    if( !v4.b_bool )
    {
        if( v6.b_bool )
            sock.v6only = 1;

        /* try IPv6 first (unless IPv4 forced) */
        private = p_this->p_private;
        p_this->p_private = (void*)&sock;
        p_network = module_Need( p_this, "network", "ipv6", VLC_TRUE );

        if( p_network != NULL )
            module_Unneed( p_this, p_network );

        p_this->p_private = private;

        /*
         * Check if the IP stack can receive IPv4 packets on IPv6 sockets.
         * If yes, then it is better to use the IPv6 socket.
         * Otherwise, if we also get an IPv4, we have to choose, so we use
         * IPv4 only.
         */
        if( ( sock.i_handle != -1 ) && ( ( sock.v6only == 0 ) || v6.b_bool ) )
            return sock.i_handle;
    }

    if( !v6.b_bool )
    {
        int fd6 = sock.i_handle;

        /* also try IPv4 (unless IPv6 forced) */
        private = p_this->p_private;
        p_this->p_private = (void*)&sock;
        p_network = module_Need( p_this, "network", "ipv4", VLC_TRUE );

        if( p_network != NULL )
            module_Unneed( p_this, p_network );

        p_this->p_private = private;

        if( fd6 != -1 )
        {
            if( sock.i_handle != -1 )
            {
498
499
                msg_Warn( p_this, "net: lame IPv6/IPv4 dual-stack present, "
                                  "using only IPv4." );
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
500
501
502
503
504
505
506
507
508
509
510
511
512
                net_Close( fd6 );
            }
            else
                sock.i_handle = fd6;
        }
    }

    if( sock.i_handle == -1 )
        msg_Dbg( p_this, "net: connection to '[%s]:%d@[%s]:%d' failed",
                psz_server, i_server, psz_bind, i_bind );

    return sock.i_handle;
}