Merge commit '9d12dd6fa84d9f6094bdf0fdae62527ecec0bbb6'
[ffmpeg.git] / libavformat / tcp.c
1 /*
2  * TCP protocol
3  * Copyright (c) 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 #include "avformat.h"
22 #include "libavutil/avassert.h"
23 #include "libavutil/parseutils.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/time.h"
26
27 #include "internal.h"
28 #include "network.h"
29 #include "os_support.h"
30 #include "url.h"
31 #if HAVE_POLL_H
32 #include <poll.h>
33 #endif
34
35 typedef struct TCPContext {
36     const AVClass *class;
37     int fd;
38     int listen;
39     int open_timeout;
40     int rw_timeout;
41     int listen_timeout;
42     int recv_buffer_size;
43     int send_buffer_size;
44 } TCPContext;
45
46 #define OFFSET(x) offsetof(TCPContext, x)
47 #define D AV_OPT_FLAG_DECODING_PARAM
48 #define E AV_OPT_FLAG_ENCODING_PARAM
49 static const AVOption options[] = {
50     { "listen",          "Listen for incoming connections",  OFFSET(listen),         AV_OPT_TYPE_INT, { .i64 = 0 },     0,       2,       .flags = D|E },
51     { "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 },
52     { "listen_timeout",  "Connection awaiting timeout (in milliseconds)",      OFFSET(listen_timeout), AV_OPT_TYPE_INT, { .i64 = -1 },         -1, INT_MAX, .flags = D|E },
53     { "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 },
54     { "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 },
55     { NULL }
56 };
57
58 static const AVClass tcp_class = {
59     .class_name = "tcp",
60     .item_name  = av_default_item_name,
61     .option     = options,
62     .version    = LIBAVUTIL_VERSION_INT,
63 };
64
65 /* return non zero if error */
66 static int tcp_open(URLContext *h, const char *uri, int flags)
67 {
68     struct addrinfo hints = { 0 }, *ai, *cur_ai;
69     int port, fd = -1;
70     TCPContext *s = h->priv_data;
71     const char *p;
72     char buf[256];
73     int ret;
74     char hostname[1024],proto[1024],path[1024];
75     char portstr[10];
76     s->open_timeout = 5000000;
77
78     av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname),
79         &port, path, sizeof(path), uri);
80     if (strcmp(proto, "tcp"))
81         return AVERROR(EINVAL);
82     if (port <= 0 || port >= 65536) {
83         av_log(h, AV_LOG_ERROR, "Port missing in uri\n");
84         return AVERROR(EINVAL);
85     }
86     p = strchr(uri, '?');
87     if (p) {
88         if (av_find_info_tag(buf, sizeof(buf), "listen", p)) {
89             char *endptr = NULL;
90             s->listen = strtol(buf, &endptr, 10);
91             /* assume if no digits were found it is a request to enable it */
92             if (buf == endptr)
93                 s->listen = 1;
94         }
95         if (av_find_info_tag(buf, sizeof(buf), "timeout", p)) {
96             s->rw_timeout = strtol(buf, NULL, 10);
97         }
98         if (av_find_info_tag(buf, sizeof(buf), "listen_timeout", p)) {
99             s->listen_timeout = strtol(buf, NULL, 10);
100         }
101     }
102     if (s->rw_timeout >= 0) {
103         s->open_timeout =
104         h->rw_timeout   = s->rw_timeout;
105     }
106     hints.ai_family = AF_UNSPEC;
107     hints.ai_socktype = SOCK_STREAM;
108     snprintf(portstr, sizeof(portstr), "%d", port);
109     if (s->listen)
110         hints.ai_flags |= AI_PASSIVE;
111     if (!hostname[0])
112         ret = getaddrinfo(NULL, portstr, &hints, &ai);
113     else
114         ret = getaddrinfo(hostname, portstr, &hints, &ai);
115     if (ret) {
116         av_log(h, AV_LOG_ERROR,
117                "Failed to resolve hostname %s: %s\n",
118                hostname, gai_strerror(ret));
119         return AVERROR(EIO);
120     }
121
122     cur_ai = ai;
123
124  restart:
125 #if HAVE_STRUCT_SOCKADDR_IN6
126     // workaround for IOS9 getaddrinfo in IPv6 only network use hardcode IPv4 address can not resolve port number.
127     if (cur_ai->ai_family == AF_INET6){
128         struct sockaddr_in6 * sockaddr_v6 = (struct sockaddr_in6 *)cur_ai->ai_addr;
129         if (!sockaddr_v6->sin6_port){
130             sockaddr_v6->sin6_port = htons(port);
131         }
132     }
133 #endif
134
135     fd = ff_socket(cur_ai->ai_family,
136                    cur_ai->ai_socktype,
137                    cur_ai->ai_protocol);
138     if (fd < 0) {
139         ret = ff_neterrno();
140         goto fail;
141     }
142
143     /* Set the socket's send or receive buffer sizes, if specified.
144        If unspecified or setting fails, system default is used. */
145     if (s->recv_buffer_size > 0) {
146         setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &s->recv_buffer_size, sizeof (s->recv_buffer_size));
147     }
148     if (s->send_buffer_size > 0) {
149         setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &s->send_buffer_size, sizeof (s->send_buffer_size));
150     }
151
152     if (s->listen == 2) {
153         // multi-client
154         if ((ret = ff_listen(fd, cur_ai->ai_addr, cur_ai->ai_addrlen)) < 0)
155             goto fail1;
156     } else if (s->listen == 1) {
157         // single client
158         if ((ret = ff_listen_bind(fd, cur_ai->ai_addr, cur_ai->ai_addrlen,
159                                   s->listen_timeout, h)) < 0)
160             goto fail1;
161         // Socket descriptor already closed here. Safe to overwrite to client one.
162         fd = ret;
163     } else {
164         if ((ret = ff_listen_connect(fd, cur_ai->ai_addr, cur_ai->ai_addrlen,
165                                      s->open_timeout / 1000, h, !!cur_ai->ai_next)) < 0) {
166
167             if (ret == AVERROR_EXIT)
168                 goto fail1;
169             else
170                 goto fail;
171         }
172     }
173
174     h->is_streamed = 1;
175     s->fd = fd;
176
177     freeaddrinfo(ai);
178     return 0;
179
180  fail:
181     if (cur_ai->ai_next) {
182         /* Retry with the next sockaddr */
183         cur_ai = cur_ai->ai_next;
184         if (fd >= 0)
185             closesocket(fd);
186         ret = 0;
187         goto restart;
188     }
189  fail1:
190     if (fd >= 0)
191         closesocket(fd);
192     freeaddrinfo(ai);
193     return ret;
194 }
195
196 static int tcp_accept(URLContext *s, URLContext **c)
197 {
198     TCPContext *sc = s->priv_data;
199     TCPContext *cc;
200     int ret;
201     av_assert0(sc->listen);
202     if ((ret = ffurl_alloc(c, s->filename, s->flags, &s->interrupt_callback)) < 0)
203         return ret;
204     cc = (*c)->priv_data;
205     ret = ff_accept(sc->fd, sc->listen_timeout, s);
206     if (ret < 0)
207         return ret;
208     cc->fd = ret;
209     return 0;
210 }
211
212 static int tcp_read(URLContext *h, uint8_t *buf, int size)
213 {
214     TCPContext *s = h->priv_data;
215     int ret;
216
217     if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
218         ret = ff_network_wait_fd_timeout(s->fd, 0, h->rw_timeout, &h->interrupt_callback);
219         if (ret)
220             return ret;
221     }
222     ret = recv(s->fd, buf, size, 0);
223     return ret < 0 ? ff_neterrno() : ret;
224 }
225
226 static int tcp_write(URLContext *h, const uint8_t *buf, int size)
227 {
228     TCPContext *s = h->priv_data;
229     int ret;
230
231     if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
232         ret = ff_network_wait_fd_timeout(s->fd, 1, h->rw_timeout, &h->interrupt_callback);
233         if (ret)
234             return ret;
235     }
236     ret = send(s->fd, buf, size, MSG_NOSIGNAL);
237     return ret < 0 ? ff_neterrno() : ret;
238 }
239
240 static int tcp_shutdown(URLContext *h, int flags)
241 {
242     TCPContext *s = h->priv_data;
243     int how;
244
245     if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {
246         how = SHUT_RDWR;
247     } else if (flags & AVIO_FLAG_WRITE) {
248         how = SHUT_WR;
249     } else {
250         how = SHUT_RD;
251     }
252
253     return shutdown(s->fd, how);
254 }
255
256 static int tcp_close(URLContext *h)
257 {
258     TCPContext *s = h->priv_data;
259     closesocket(s->fd);
260     return 0;
261 }
262
263 static int tcp_get_file_handle(URLContext *h)
264 {
265     TCPContext *s = h->priv_data;
266     return s->fd;
267 }
268
269 static int tcp_get_window_size(URLContext *h)
270 {
271     TCPContext *s = h->priv_data;
272     int avail;
273     int avail_len = sizeof(avail);
274
275 #if HAVE_WINSOCK2_H
276     /* SO_RCVBUF with winsock only reports the actual TCP window size when
277     auto-tuning has been disabled via setting SO_RCVBUF */
278     if (s->recv_buffer_size < 0) {
279         return AVERROR(ENOSYS);
280     }
281 #endif
282
283     if (getsockopt(s->fd, SOL_SOCKET, SO_RCVBUF, &avail, &avail_len)) {
284         return ff_neterrno();
285     }
286     return avail;
287 }
288
289 const URLProtocol ff_tcp_protocol = {
290     .name                = "tcp",
291     .url_open            = tcp_open,
292     .url_accept          = tcp_accept,
293     .url_read            = tcp_read,
294     .url_write           = tcp_write,
295     .url_close           = tcp_close,
296     .url_get_file_handle = tcp_get_file_handle,
297     .url_get_short_seek  = tcp_get_window_size,
298     .url_shutdown        = tcp_shutdown,
299     .priv_data_size      = sizeof(TCPContext),
300     .flags               = URL_PROTOCOL_FLAG_NETWORK,
301     .priv_data_class     = &tcp_class,
302 };