Statistics
| Branch: | Revision:

ffmpeg / libavformat / udp.c @ f3bfe388

History | View | Annotate | Download (14.3 KB)

1
/*
2
 * UDP prototype streaming system
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * @file
24
 * UDP protocol
25
 */
26

    
27
#define _BSD_SOURCE     /* Needed for using struct ip_mreq with recent glibc */
28
#include "avformat.h"
29
#include <unistd.h>
30
#include "internal.h"
31
#include "network.h"
32
#include "os_support.h"
33
#if HAVE_SYS_SELECT_H
34
#include <sys/select.h>
35
#endif
36
#include <sys/time.h>
37

    
38
#ifndef IPV6_ADD_MEMBERSHIP
39
#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
40
#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
41
#endif
42
#ifndef IN_MULTICAST
43
#define IN_MULTICAST(a) ((((uint32_t)(a)) & 0xf0000000) == 0xe0000000)
44
#endif
45
#ifndef IN6_IS_ADDR_MULTICAST
46
#define IN6_IS_ADDR_MULTICAST(a) (((uint8_t *) (a))[0] == 0xff)
47
#endif
48

    
49
typedef struct {
50
    int udp_fd;
51
    int ttl;
52
    int buffer_size;
53
    int is_multicast;
54
    int local_port;
55
    int reuse_socket;
56
    struct sockaddr_storage dest_addr;
57
    int dest_addr_len;
58
} UDPContext;
59

    
60
#define UDP_TX_BUF_SIZE 32768
61
#define UDP_MAX_PKT_SIZE 65536
62

    
63
static int udp_set_multicast_ttl(int sockfd, int mcastTTL,
64
                                 struct sockaddr *addr)
65
{
66
#ifdef IP_MULTICAST_TTL
67
    if (addr->sa_family == AF_INET) {
68
        if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &mcastTTL, sizeof(mcastTTL)) < 0) {
69
            av_log(NULL, AV_LOG_ERROR, "setsockopt(IP_MULTICAST_TTL): %s\n", strerror(errno));
70
            return -1;
71
        }
72
    }
73
#endif
74
#if defined(IPPROTO_IPV6) && defined(IPV6_MULTICAST_HOPS)
75
    if (addr->sa_family == AF_INET6) {
76
        if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &mcastTTL, sizeof(mcastTTL)) < 0) {
77
            av_log(NULL, AV_LOG_ERROR, "setsockopt(IPV6_MULTICAST_HOPS): %s\n", strerror(errno));
78
            return -1;
79
        }
80
    }
81
#endif
82
    return 0;
83
}
84

    
85
static int udp_join_multicast_group(int sockfd, struct sockaddr *addr)
86
{
87
#ifdef IP_ADD_MEMBERSHIP
88
    if (addr->sa_family == AF_INET) {
89
        struct ip_mreq mreq;
90

    
91
        mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
92
        mreq.imr_interface.s_addr= INADDR_ANY;
93
        if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
94
            av_log(NULL, AV_LOG_ERROR, "setsockopt(IP_ADD_MEMBERSHIP): %s\n", strerror(errno));
95
            return -1;
96
        }
97
    }
98
#endif
99
#if HAVE_STRUCT_IPV6_MREQ
100
    if (addr->sa_family == AF_INET6) {
101
        struct ipv6_mreq mreq6;
102

    
103
        memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
104
        mreq6.ipv6mr_interface= 0;
105
        if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
106
            av_log(NULL, AV_LOG_ERROR, "setsockopt(IPV6_ADD_MEMBERSHIP): %s\n", strerror(errno));
107
            return -1;
108
        }
109
    }
110
#endif
111
    return 0;
112
}
113

    
114
static int udp_leave_multicast_group(int sockfd, struct sockaddr *addr)
115
{
116
#ifdef IP_DROP_MEMBERSHIP
117
    if (addr->sa_family == AF_INET) {
118
        struct ip_mreq mreq;
119

    
120
        mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
121
        mreq.imr_interface.s_addr= INADDR_ANY;
122
        if (setsockopt(sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
123
            av_log(NULL, AV_LOG_ERROR, "setsockopt(IP_DROP_MEMBERSHIP): %s\n", strerror(errno));
124
            return -1;
125
        }
126
    }
127
#endif
128
#if HAVE_STRUCT_IPV6_MREQ
129
    if (addr->sa_family == AF_INET6) {
130
        struct ipv6_mreq mreq6;
131

    
132
        memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
133
        mreq6.ipv6mr_interface= 0;
134
        if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
135
            av_log(NULL, AV_LOG_ERROR, "setsockopt(IPV6_DROP_MEMBERSHIP): %s\n", strerror(errno));
136
            return -1;
137
        }
138
    }
139
#endif
140
    return 0;
141
}
142

    
143
static struct addrinfo* udp_resolve_host(const char *hostname, int port,
144
                                         int type, int family, int flags)
145
{
146
    struct addrinfo hints, *res = 0;
147
    int error;
148
    char sport[16];
149
    const char *node = 0, *service = "0";
150

    
151
    if (port > 0) {
152
        snprintf(sport, sizeof(sport), "%d", port);
153
        service = sport;
154
    }
155
    if ((hostname) && (hostname[0] != '\0') && (hostname[0] != '?')) {
156
        node = hostname;
157
    }
158
    memset(&hints, 0, sizeof(hints));
159
    hints.ai_socktype = type;
160
    hints.ai_family   = family;
161
    hints.ai_flags = flags;
162
    if ((error = getaddrinfo(node, service, &hints, &res))) {
163
        res = NULL;
164
        av_log(NULL, AV_LOG_ERROR, "udp_resolve_host: %s\n", gai_strerror(error));
165
    }
166

    
167
    return res;
168
}
169

    
170
static int udp_set_url(struct sockaddr_storage *addr,
171
                       const char *hostname, int port)
172
{
173
    struct addrinfo *res0;
174
    int addr_len;
175

    
176
    res0 = udp_resolve_host(hostname, port, SOCK_DGRAM, AF_UNSPEC, 0);
177
    if (res0 == 0) return AVERROR(EIO);
178
    memcpy(addr, res0->ai_addr, res0->ai_addrlen);
179
    addr_len = res0->ai_addrlen;
180
    freeaddrinfo(res0);
181

    
182
    return addr_len;
183
}
184

    
185
static int is_multicast_address(struct sockaddr_storage *addr)
186
{
187
    if (addr->ss_family == AF_INET) {
188
        return IN_MULTICAST(ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr));
189
    }
190
#if HAVE_STRUCT_SOCKADDR_IN6
191
    if (addr->ss_family == AF_INET6) {
192
        return IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *)addr)->sin6_addr);
193
    }
194
#endif
195

    
196
    return 0;
197
}
198

    
199
static int udp_socket_create(UDPContext *s,
200
                             struct sockaddr_storage *addr, int *addr_len)
201
{
202
    int udp_fd = -1;
203
    struct addrinfo *res0 = NULL, *res = NULL;
204
    int family = AF_UNSPEC;
205

    
206
    if (((struct sockaddr *) &s->dest_addr)->sa_family)
207
        family = ((struct sockaddr *) &s->dest_addr)->sa_family;
208
    res0 = udp_resolve_host(0, s->local_port, SOCK_DGRAM, family, AI_PASSIVE);
209
    if (res0 == 0)
210
        goto fail;
211
    for (res = res0; res; res=res->ai_next) {
212
        udp_fd = socket(res->ai_family, SOCK_DGRAM, 0);
213
        if (udp_fd > 0) break;
214
        av_log(NULL, AV_LOG_ERROR, "socket: %s\n", strerror(errno));
215
    }
216

    
217
    if (udp_fd < 0)
218
        goto fail;
219

    
220
    memcpy(addr, res->ai_addr, res->ai_addrlen);
221
    *addr_len = res->ai_addrlen;
222

    
223
    freeaddrinfo(res0);
224

    
225
    return udp_fd;
226

    
227
 fail:
228
    if (udp_fd >= 0)
229
        closesocket(udp_fd);
230
    if(res0)
231
        freeaddrinfo(res0);
232
    return -1;
233
}
234

    
235
static int udp_port(struct sockaddr_storage *addr, int addr_len)
236
{
237
    char sbuf[sizeof(int)*3+1];
238

    
239
    if (getnameinfo((struct sockaddr *)addr, addr_len, NULL, 0,  sbuf, sizeof(sbuf), NI_NUMERICSERV) != 0) {
240
        av_log(NULL, AV_LOG_ERROR, "getnameinfo: %s\n", strerror(errno));
241
        return -1;
242
    }
243

    
244
    return strtol(sbuf, NULL, 10);
245
}
246

    
247

    
248
/**
249
 * If no filename is given to av_open_input_file because you want to
250
 * get the local port first, then you must call this function to set
251
 * the remote server address.
252
 *
253
 * url syntax: udp://host:port[?option=val...]
254
 * option: 'ttl=n'       : set the ttl value (for multicast only)
255
 *         'localport=n' : set the local port
256
 *         'pkt_size=n'  : set max packet size
257
 *         'reuse=1'     : enable reusing the socket
258
 *
259
 * @param s1 media file context
260
 * @param uri of the remote server
261
 * @return zero if no error.
262
 */
263
int udp_set_remote_url(URLContext *h, const char *uri)
264
{
265
    UDPContext *s = h->priv_data;
266
    char hostname[256];
267
    int port;
268

    
269
    av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
270

    
271
    /* set the destination address */
272
    s->dest_addr_len = udp_set_url(&s->dest_addr, hostname, port);
273
    if (s->dest_addr_len < 0) {
274
        return AVERROR(EIO);
275
    }
276
    s->is_multicast = is_multicast_address(&s->dest_addr);
277

    
278
    return 0;
279
}
280

    
281
/**
282
 * Return the local port used by the UDP connection
283
 * @param s1 media file context
284
 * @return the local port number
285
 */
286
int udp_get_local_port(URLContext *h)
287
{
288
    UDPContext *s = h->priv_data;
289
    return s->local_port;
290
}
291

    
292
/**
293
 * Return the udp file handle for select() usage to wait for several RTP
294
 * streams at the same time.
295
 * @param h media file context
296
 */
297
#if (LIBAVFORMAT_VERSION_MAJOR >= 53)
298
static
299
#endif
300
int udp_get_file_handle(URLContext *h)
301
{
302
    UDPContext *s = h->priv_data;
303
    return s->udp_fd;
304
}
305

    
306
/* put it in UDP context */
307
/* return non zero if error */
308
static int udp_open(URLContext *h, const char *uri, int flags)
309
{
310
    char hostname[1024];
311
    int port, udp_fd = -1, tmp, bind_ret = -1;
312
    UDPContext *s = NULL;
313
    int is_output;
314
    const char *p;
315
    char buf[256];
316
    struct sockaddr_storage my_addr;
317
    int len;
318

    
319
    h->is_streamed = 1;
320
    h->max_packet_size = 1472;
321

    
322
    is_output = (flags & URL_WRONLY);
323

    
324
    s = av_mallocz(sizeof(UDPContext));
325
    if (!s)
326
        return AVERROR(ENOMEM);
327

    
328
    h->priv_data = s;
329
    s->ttl = 16;
330
    s->buffer_size = is_output ? UDP_TX_BUF_SIZE : UDP_MAX_PKT_SIZE;
331

    
332
    p = strchr(uri, '?');
333
    if (p) {
334
        s->reuse_socket = find_info_tag(buf, sizeof(buf), "reuse", p);
335
        if (find_info_tag(buf, sizeof(buf), "ttl", p)) {
336
            s->ttl = strtol(buf, NULL, 10);
337
        }
338
        if (find_info_tag(buf, sizeof(buf), "localport", p)) {
339
            s->local_port = strtol(buf, NULL, 10);
340
        }
341
        if (find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
342
            h->max_packet_size = strtol(buf, NULL, 10);
343
        }
344
        if (find_info_tag(buf, sizeof(buf), "buffer_size", p)) {
345
            s->buffer_size = strtol(buf, NULL, 10);
346
        }
347
    }
348

    
349
    /* fill the dest addr */
350
    av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
351

    
352
    /* XXX: fix av_url_split */
353
    if (hostname[0] == '\0' || hostname[0] == '?') {
354
        /* only accepts null hostname if input */
355
        if (flags & URL_WRONLY)
356
            goto fail;
357
    } else {
358
        udp_set_remote_url(h, uri);
359
    }
360

    
361
    if (s->is_multicast && !(h->flags & URL_WRONLY))
362
        s->local_port = port;
363
    udp_fd = udp_socket_create(s, &my_addr, &len);
364
    if (udp_fd < 0)
365
        goto fail;
366

    
367
    if (s->reuse_socket)
368
        if (setsockopt (udp_fd, SOL_SOCKET, SO_REUSEADDR, &(s->reuse_socket), sizeof(s->reuse_socket)) != 0)
369
            goto fail;
370

    
371
    /* the bind is needed to give a port to the socket now */
372
    /* if multicast, try the multicast address bind first */
373
    if (s->is_multicast && !(h->flags & URL_WRONLY)) {
374
        bind_ret = bind(udp_fd,(struct sockaddr *)&s->dest_addr, len);
375
    }
376
    /* bind to the local address if not multicast or if the multicast
377
     * bind failed */
378
    if (bind_ret < 0 && bind(udp_fd,(struct sockaddr *)&my_addr, len) < 0)
379
        goto fail;
380

    
381
    len = sizeof(my_addr);
382
    getsockname(udp_fd, (struct sockaddr *)&my_addr, &len);
383
    s->local_port = udp_port(&my_addr, len);
384

    
385
    if (s->is_multicast) {
386
        if (h->flags & URL_WRONLY) {
387
            /* output */
388
            if (udp_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr) < 0)
389
                goto fail;
390
        } else {
391
            /* input */
392
            if (udp_join_multicast_group(udp_fd, (struct sockaddr *)&s->dest_addr) < 0)
393
                goto fail;
394
        }
395
    }
396

    
397
    if (is_output) {
398
        /* limit the tx buf size to limit latency */
399
        tmp = s->buffer_size;
400
        if (setsockopt(udp_fd, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)) < 0) {
401
            av_log(NULL, AV_LOG_ERROR, "setsockopt(SO_SNDBUF): %s\n", strerror(errno));
402
            goto fail;
403
        }
404
    } else {
405
        /* set udp recv buffer size to the largest possible udp packet size to
406
         * avoid losing data on OSes that set this too low by default. */
407
        tmp = s->buffer_size;
408
        if (setsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, sizeof(tmp)) < 0) {
409
            av_log(NULL, AV_LOG_WARNING, "setsockopt(SO_RECVBUF): %s\n", strerror(errno));
410
        }
411
        /* make the socket non-blocking */
412
        ff_socket_nonblock(udp_fd, 1);
413
    }
414

    
415
    s->udp_fd = udp_fd;
416
    return 0;
417
 fail:
418
    if (udp_fd >= 0)
419
        closesocket(udp_fd);
420
    av_free(s);
421
    return AVERROR(EIO);
422
}
423

    
424
static int udp_read(URLContext *h, uint8_t *buf, int size)
425
{
426
    UDPContext *s = h->priv_data;
427
    int len;
428
    fd_set rfds;
429
    int ret;
430
    struct timeval tv;
431

    
432
    for(;;) {
433
        if (url_interrupt_cb())
434
            return AVERROR(EINTR);
435
        FD_ZERO(&rfds);
436
        FD_SET(s->udp_fd, &rfds);
437
        tv.tv_sec = 0;
438
        tv.tv_usec = 100 * 1000;
439
        ret = select(s->udp_fd + 1, &rfds, NULL, NULL, &tv);
440
        if (ret < 0) {
441
            if (ff_neterrno() == FF_NETERROR(EINTR))
442
                continue;
443
            return AVERROR(EIO);
444
        }
445
        if (!(ret > 0 && FD_ISSET(s->udp_fd, &rfds)))
446
            continue;
447
        len = recv(s->udp_fd, buf, size, 0);
448
        if (len < 0) {
449
            if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
450
                ff_neterrno() != FF_NETERROR(EINTR))
451
                return AVERROR(EIO);
452
        } else {
453
            break;
454
        }
455
    }
456
    return len;
457
}
458

    
459
static int udp_write(URLContext *h, const uint8_t *buf, int size)
460
{
461
    UDPContext *s = h->priv_data;
462
    int ret;
463

    
464
    for(;;) {
465
        ret = sendto (s->udp_fd, buf, size, 0,
466
                      (struct sockaddr *) &s->dest_addr,
467
                      s->dest_addr_len);
468
        if (ret < 0) {
469
            if (ff_neterrno() != FF_NETERROR(EINTR) &&
470
                ff_neterrno() != FF_NETERROR(EAGAIN))
471
                return AVERROR(EIO);
472
        } else {
473
            break;
474
        }
475
    }
476
    return size;
477
}
478

    
479
static int udp_close(URLContext *h)
480
{
481
    UDPContext *s = h->priv_data;
482

    
483
    if (s->is_multicast && !(h->flags & URL_WRONLY))
484
        udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr);
485
    closesocket(s->udp_fd);
486
    av_free(s);
487
    return 0;
488
}
489

    
490
URLProtocol udp_protocol = {
491
    "udp",
492
    udp_open,
493
    udp_read,
494
    udp_write,
495
    NULL, /* seek */
496
    udp_close,
497
    .url_get_file_handle = udp_get_file_handle,
498
};