mirror of
https://git.ffmpeg.org/ffmpeg.git
synced 2024-12-27 01:42:20 +00:00
790f793844
There are lots of files that don't need it: The number of object files that actually need it went down from 2011 to 884 here. Keep it for external users in order to not cause breakages. Also improve the other headers a bit while just at it. Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
379 lines
12 KiB
C
379 lines
12 KiB
C
/*
|
|
* TCP protocol
|
|
* Copyright (c) 2002 Fabrice Bellard
|
|
*
|
|
* This file is part of FFmpeg.
|
|
*
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* FFmpeg 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
#include "avformat.h"
|
|
#include "libavutil/avassert.h"
|
|
#include "libavutil/mem.h"
|
|
#include "libavutil/parseutils.h"
|
|
#include "libavutil/opt.h"
|
|
#include "libavutil/time.h"
|
|
|
|
#include "network.h"
|
|
#include "os_support.h"
|
|
#include "url.h"
|
|
#if HAVE_POLL_H
|
|
#include <poll.h>
|
|
#endif
|
|
|
|
typedef struct TCPContext {
|
|
const AVClass *class;
|
|
int fd;
|
|
int listen;
|
|
char *local_port;
|
|
char *local_addr;
|
|
int open_timeout;
|
|
int rw_timeout;
|
|
int listen_timeout;
|
|
int recv_buffer_size;
|
|
int send_buffer_size;
|
|
int tcp_nodelay;
|
|
#if !HAVE_WINSOCK2_H
|
|
int tcp_mss;
|
|
#endif /* !HAVE_WINSOCK2_H */
|
|
} TCPContext;
|
|
|
|
#define OFFSET(x) offsetof(TCPContext, x)
|
|
#define D AV_OPT_FLAG_DECODING_PARAM
|
|
#define E AV_OPT_FLAG_ENCODING_PARAM
|
|
static const AVOption options[] = {
|
|
{ "listen", "Listen for incoming connections", OFFSET(listen), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, .flags = D|E },
|
|
{ "local_port", "Local port", OFFSET(local_port), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, .flags = D|E },
|
|
{ "local_addr", "Local address", OFFSET(local_addr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, .flags = D|E },
|
|
{ "timeout", "set timeout (in microseconds) of socket I/O operations", OFFSET(rw_timeout), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
|
|
{ "listen_timeout", "Connection awaiting timeout (in milliseconds)", OFFSET(listen_timeout), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
|
|
{ "send_buffer_size", "Socket send buffer size (in bytes)", OFFSET(send_buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
|
|
{ "recv_buffer_size", "Socket receive buffer size (in bytes)", OFFSET(recv_buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
|
|
{ "tcp_nodelay", "Use TCP_NODELAY to disable nagle's algorithm", OFFSET(tcp_nodelay), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = D|E },
|
|
#if !HAVE_WINSOCK2_H
|
|
{ "tcp_mss", "Maximum segment size for outgoing TCP packets", OFFSET(tcp_mss), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
|
|
#endif /* !HAVE_WINSOCK2_H */
|
|
{ NULL }
|
|
};
|
|
|
|
static const AVClass tcp_class = {
|
|
.class_name = "tcp",
|
|
.item_name = av_default_item_name,
|
|
.option = options,
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
};
|
|
|
|
static int customize_fd(void *ctx, int fd, int family)
|
|
{
|
|
TCPContext *s = ctx;
|
|
|
|
if (s->local_addr || s->local_port) {
|
|
struct addrinfo hints = { 0 }, *ai, *cur_ai;
|
|
int ret;
|
|
|
|
hints.ai_family = family;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
ret = getaddrinfo(s->local_addr, s->local_port, &hints, &ai);
|
|
if (ret) {
|
|
av_log(ctx, AV_LOG_ERROR,
|
|
"Failed to getaddrinfo local addr: %s port: %s err: %s\n",
|
|
s->local_addr, s->local_port, gai_strerror(ret));
|
|
return ret;
|
|
}
|
|
|
|
cur_ai = ai;
|
|
while (cur_ai) {
|
|
ret = bind(fd, (struct sockaddr *)cur_ai->ai_addr, (int)cur_ai->ai_addrlen);
|
|
if (ret)
|
|
cur_ai = cur_ai->ai_next;
|
|
else
|
|
break;
|
|
}
|
|
freeaddrinfo(ai);
|
|
|
|
if (ret) {
|
|
ff_log_net_error(ctx, AV_LOG_ERROR, "bind local failed");
|
|
return ret;
|
|
}
|
|
}
|
|
/* Set the socket's send or receive buffer sizes, if specified.
|
|
If unspecified or setting fails, system default is used. */
|
|
if (s->recv_buffer_size > 0) {
|
|
if (setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &s->recv_buffer_size, sizeof (s->recv_buffer_size))) {
|
|
ff_log_net_error(ctx, AV_LOG_WARNING, "setsockopt(SO_RCVBUF)");
|
|
}
|
|
}
|
|
if (s->send_buffer_size > 0) {
|
|
if (setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &s->send_buffer_size, sizeof (s->send_buffer_size))) {
|
|
ff_log_net_error(ctx, AV_LOG_WARNING, "setsockopt(SO_SNDBUF)");
|
|
}
|
|
}
|
|
if (s->tcp_nodelay > 0) {
|
|
if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &s->tcp_nodelay, sizeof (s->tcp_nodelay))) {
|
|
ff_log_net_error(ctx, AV_LOG_WARNING, "setsockopt(TCP_NODELAY)");
|
|
}
|
|
}
|
|
#if !HAVE_WINSOCK2_H
|
|
if (s->tcp_mss > 0) {
|
|
if (setsockopt (fd, IPPROTO_TCP, TCP_MAXSEG, &s->tcp_mss, sizeof (s->tcp_mss))) {
|
|
ff_log_net_error(ctx, AV_LOG_WARNING, "setsockopt(TCP_MAXSEG)");
|
|
}
|
|
}
|
|
#endif /* !HAVE_WINSOCK2_H */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* return non zero if error */
|
|
static int tcp_open(URLContext *h, const char *uri, int flags)
|
|
{
|
|
struct addrinfo hints = { 0 }, *ai, *cur_ai;
|
|
int port, fd = -1;
|
|
TCPContext *s = h->priv_data;
|
|
const char *p;
|
|
char buf[256];
|
|
int ret;
|
|
char hostname[1024],proto[1024],path[1024];
|
|
char portstr[10];
|
|
s->open_timeout = 5000000;
|
|
|
|
av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname),
|
|
&port, path, sizeof(path), uri);
|
|
if (strcmp(proto, "tcp"))
|
|
return AVERROR(EINVAL);
|
|
if (port <= 0 || port >= 65536) {
|
|
av_log(h, AV_LOG_ERROR, "Port missing in uri\n");
|
|
return AVERROR(EINVAL);
|
|
}
|
|
p = strchr(uri, '?');
|
|
if (p) {
|
|
if (av_find_info_tag(buf, sizeof(buf), "listen", p)) {
|
|
char *endptr = NULL;
|
|
s->listen = strtol(buf, &endptr, 10);
|
|
/* assume if no digits were found it is a request to enable it */
|
|
if (buf == endptr)
|
|
s->listen = 1;
|
|
}
|
|
if (av_find_info_tag(buf, sizeof(buf), "local_port", p)) {
|
|
av_freep(&s->local_port);
|
|
s->local_port = av_strdup(buf);
|
|
if (!s->local_port)
|
|
return AVERROR(ENOMEM);
|
|
}
|
|
if (av_find_info_tag(buf, sizeof(buf), "local_addr", p)) {
|
|
av_freep(&s->local_addr);
|
|
s->local_addr = av_strdup(buf);
|
|
if (!s->local_addr)
|
|
return AVERROR(ENOMEM);
|
|
}
|
|
if (av_find_info_tag(buf, sizeof(buf), "timeout", p)) {
|
|
s->rw_timeout = strtol(buf, NULL, 10);
|
|
}
|
|
if (av_find_info_tag(buf, sizeof(buf), "listen_timeout", p)) {
|
|
s->listen_timeout = strtol(buf, NULL, 10);
|
|
}
|
|
if (av_find_info_tag(buf, sizeof(buf), "tcp_nodelay", p)) {
|
|
s->tcp_nodelay = strtol(buf, NULL, 10);
|
|
}
|
|
}
|
|
if (s->rw_timeout >= 0) {
|
|
s->open_timeout =
|
|
h->rw_timeout = s->rw_timeout;
|
|
}
|
|
hints.ai_family = AF_UNSPEC;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
snprintf(portstr, sizeof(portstr), "%d", port);
|
|
if (s->listen)
|
|
hints.ai_flags |= AI_PASSIVE;
|
|
if (!hostname[0])
|
|
ret = getaddrinfo(NULL, portstr, &hints, &ai);
|
|
else
|
|
ret = getaddrinfo(hostname, portstr, &hints, &ai);
|
|
if (ret) {
|
|
av_log(h, AV_LOG_ERROR,
|
|
"Failed to resolve hostname %s: %s\n",
|
|
hostname, gai_strerror(ret));
|
|
return AVERROR(EIO);
|
|
}
|
|
|
|
cur_ai = ai;
|
|
|
|
#if HAVE_STRUCT_SOCKADDR_IN6
|
|
// workaround for IOS9 getaddrinfo in IPv6 only network use hardcode IPv4 address can not resolve port number.
|
|
if (cur_ai->ai_family == AF_INET6){
|
|
struct sockaddr_in6 * sockaddr_v6 = (struct sockaddr_in6 *)cur_ai->ai_addr;
|
|
if (!sockaddr_v6->sin6_port){
|
|
sockaddr_v6->sin6_port = htons(port);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (s->listen > 0) {
|
|
while (cur_ai && fd < 0) {
|
|
fd = ff_socket(cur_ai->ai_family,
|
|
cur_ai->ai_socktype,
|
|
cur_ai->ai_protocol, h);
|
|
if (fd < 0) {
|
|
ret = ff_neterrno();
|
|
cur_ai = cur_ai->ai_next;
|
|
}
|
|
}
|
|
if (fd < 0)
|
|
goto fail1;
|
|
customize_fd(s, fd, cur_ai->ai_family);
|
|
}
|
|
|
|
if (s->listen == 2) {
|
|
// multi-client
|
|
if ((ret = ff_listen(fd, cur_ai->ai_addr, cur_ai->ai_addrlen, h)) < 0)
|
|
goto fail1;
|
|
} else if (s->listen == 1) {
|
|
// single client
|
|
if ((ret = ff_listen_bind(fd, cur_ai->ai_addr, cur_ai->ai_addrlen,
|
|
s->listen_timeout, h)) < 0)
|
|
goto fail1;
|
|
// Socket descriptor already closed here. Safe to overwrite to client one.
|
|
fd = ret;
|
|
} else {
|
|
ret = ff_connect_parallel(ai, s->open_timeout / 1000, 3, h, &fd, customize_fd, s);
|
|
if (ret < 0)
|
|
goto fail1;
|
|
}
|
|
|
|
h->is_streamed = 1;
|
|
s->fd = fd;
|
|
|
|
freeaddrinfo(ai);
|
|
return 0;
|
|
|
|
fail1:
|
|
if (fd >= 0)
|
|
closesocket(fd);
|
|
freeaddrinfo(ai);
|
|
return ret;
|
|
}
|
|
|
|
static int tcp_accept(URLContext *s, URLContext **c)
|
|
{
|
|
TCPContext *sc = s->priv_data;
|
|
TCPContext *cc;
|
|
int ret;
|
|
av_assert0(sc->listen);
|
|
if ((ret = ffurl_alloc(c, s->filename, s->flags, &s->interrupt_callback)) < 0)
|
|
return ret;
|
|
cc = (*c)->priv_data;
|
|
ret = ff_accept(sc->fd, sc->listen_timeout, s);
|
|
if (ret < 0) {
|
|
ffurl_closep(c);
|
|
return ret;
|
|
}
|
|
cc->fd = ret;
|
|
return 0;
|
|
}
|
|
|
|
static int tcp_read(URLContext *h, uint8_t *buf, int size)
|
|
{
|
|
TCPContext *s = h->priv_data;
|
|
int ret;
|
|
|
|
if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
|
|
ret = ff_network_wait_fd_timeout(s->fd, 0, h->rw_timeout, &h->interrupt_callback);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
ret = recv(s->fd, buf, size, 0);
|
|
if (ret == 0)
|
|
return AVERROR_EOF;
|
|
return ret < 0 ? ff_neterrno() : ret;
|
|
}
|
|
|
|
static int tcp_write(URLContext *h, const uint8_t *buf, int size)
|
|
{
|
|
TCPContext *s = h->priv_data;
|
|
int ret;
|
|
|
|
if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
|
|
ret = ff_network_wait_fd_timeout(s->fd, 1, h->rw_timeout, &h->interrupt_callback);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
ret = send(s->fd, buf, size, MSG_NOSIGNAL);
|
|
return ret < 0 ? ff_neterrno() : ret;
|
|
}
|
|
|
|
static int tcp_shutdown(URLContext *h, int flags)
|
|
{
|
|
TCPContext *s = h->priv_data;
|
|
int how;
|
|
|
|
if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {
|
|
how = SHUT_RDWR;
|
|
} else if (flags & AVIO_FLAG_WRITE) {
|
|
how = SHUT_WR;
|
|
} else {
|
|
how = SHUT_RD;
|
|
}
|
|
|
|
return shutdown(s->fd, how);
|
|
}
|
|
|
|
static int tcp_close(URLContext *h)
|
|
{
|
|
TCPContext *s = h->priv_data;
|
|
closesocket(s->fd);
|
|
return 0;
|
|
}
|
|
|
|
static int tcp_get_file_handle(URLContext *h)
|
|
{
|
|
TCPContext *s = h->priv_data;
|
|
return s->fd;
|
|
}
|
|
|
|
static int tcp_get_window_size(URLContext *h)
|
|
{
|
|
TCPContext *s = h->priv_data;
|
|
int avail;
|
|
socklen_t avail_len = sizeof(avail);
|
|
|
|
#if HAVE_WINSOCK2_H
|
|
/* SO_RCVBUF with winsock only reports the actual TCP window size when
|
|
auto-tuning has been disabled via setting SO_RCVBUF */
|
|
if (s->recv_buffer_size < 0) {
|
|
return AVERROR(ENOSYS);
|
|
}
|
|
#endif
|
|
|
|
if (getsockopt(s->fd, SOL_SOCKET, SO_RCVBUF, &avail, &avail_len)) {
|
|
return ff_neterrno();
|
|
}
|
|
return avail;
|
|
}
|
|
|
|
const URLProtocol ff_tcp_protocol = {
|
|
.name = "tcp",
|
|
.url_open = tcp_open,
|
|
.url_accept = tcp_accept,
|
|
.url_read = tcp_read,
|
|
.url_write = tcp_write,
|
|
.url_close = tcp_close,
|
|
.url_get_file_handle = tcp_get_file_handle,
|
|
.url_get_short_seek = tcp_get_window_size,
|
|
.url_shutdown = tcp_shutdown,
|
|
.priv_data_size = sizeof(TCPContext),
|
|
.flags = URL_PROTOCOL_FLAG_NETWORK,
|
|
.priv_data_class = &tcp_class,
|
|
};
|