segment: Use the public av_write_header/av_write_trailer functions
[ffmpeg.git] / libavformat / tcp.c
1 /*
2  * TCP protocol
3  * Copyright (c) 2002 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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/parseutils.h"
23 #include "internal.h"
24 #include "network.h"
25 #include "os_support.h"
26 #include "url.h"
27 #if HAVE_POLL_H
28 #include <poll.h>
29 #endif
30
31 typedef struct TCPContext {
32     int fd;
33 } TCPContext;
34
35 /* return non zero if error */
36 static int tcp_open(URLContext *h, const char *uri, int flags)
37 {
38     struct addrinfo hints = { 0 }, *ai, *cur_ai;
39     int port, fd = -1;
40     TCPContext *s = h->priv_data;
41     int listen_socket = 0;
42     const char *p;
43     char buf[256];
44     int ret;
45     socklen_t optlen;
46     int timeout = 100, listen_timeout = -1;
47     char hostname[1024],proto[1024],path[1024];
48     char portstr[10];
49
50     av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname),
51         &port, path, sizeof(path), uri);
52     if (strcmp(proto, "tcp"))
53         return AVERROR(EINVAL);
54     if (port <= 0 || port >= 65536) {
55         av_log(h, AV_LOG_ERROR, "Port missing in uri\n");
56         return AVERROR(EINVAL);
57     }
58     p = strchr(uri, '?');
59     if (p) {
60         if (av_find_info_tag(buf, sizeof(buf), "listen", p))
61             listen_socket = 1;
62         if (av_find_info_tag(buf, sizeof(buf), "timeout", p)) {
63             timeout = strtol(buf, NULL, 10);
64         }
65         if (av_find_info_tag(buf, sizeof(buf), "listen_timeout", p)) {
66             listen_timeout = strtol(buf, NULL, 10);
67         }
68     }
69     hints.ai_family = AF_UNSPEC;
70     hints.ai_socktype = SOCK_STREAM;
71     snprintf(portstr, sizeof(portstr), "%d", port);
72     if (listen_socket)
73         hints.ai_flags |= AI_PASSIVE;
74     if (!hostname[0])
75         ret = getaddrinfo(NULL, portstr, &hints, &ai);
76     else
77         ret = getaddrinfo(hostname, portstr, &hints, &ai);
78     if (ret) {
79         av_log(h, AV_LOG_ERROR,
80                "Failed to resolve hostname %s: %s\n",
81                hostname, gai_strerror(ret));
82         return AVERROR(EIO);
83     }
84
85     cur_ai = ai;
86
87  restart:
88     ret = AVERROR(EIO);
89     fd = socket(cur_ai->ai_family, cur_ai->ai_socktype, cur_ai->ai_protocol);
90     if (fd < 0)
91         goto fail;
92
93     if (listen_socket) {
94         int fd1;
95         int reuse = 1;
96         struct pollfd lp = { fd, POLLIN, 0 };
97         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
98         ret = bind(fd, cur_ai->ai_addr, cur_ai->ai_addrlen);
99         if (ret) {
100             ret = ff_neterrno();
101             goto fail1;
102         }
103         ret = listen(fd, 1);
104         if (ret) {
105             ret = ff_neterrno();
106             goto fail1;
107         }
108         ret = poll(&lp, 1, listen_timeout >= 0 ? listen_timeout : -1);
109         if (ret <= 0) {
110             ret = AVERROR(ETIMEDOUT);
111             goto fail1;
112         }
113         fd1 = accept(fd, NULL, NULL);
114         if (fd1 < 0) {
115             ret = ff_neterrno();
116             goto fail1;
117         }
118         closesocket(fd);
119         fd = fd1;
120         ff_socket_nonblock(fd, 1);
121     } else {
122  redo:
123         ff_socket_nonblock(fd, 1);
124         ret = connect(fd, cur_ai->ai_addr, cur_ai->ai_addrlen);
125     }
126
127     if (ret < 0) {
128         struct pollfd p = {fd, POLLOUT, 0};
129         ret = ff_neterrno();
130         if (ret == AVERROR(EINTR)) {
131             if (ff_check_interrupt(&h->interrupt_callback)) {
132                 ret = AVERROR_EXIT;
133                 goto fail1;
134             }
135             goto redo;
136         }
137         if (ret != AVERROR(EINPROGRESS) &&
138             ret != AVERROR(EAGAIN))
139             goto fail;
140
141         /* wait until we are connected or until abort */
142         while(timeout--) {
143             if (ff_check_interrupt(&h->interrupt_callback)) {
144                 ret = AVERROR_EXIT;
145                 goto fail1;
146             }
147             ret = poll(&p, 1, 100);
148             if (ret > 0)
149                 break;
150         }
151         if (ret <= 0) {
152             ret = AVERROR(ETIMEDOUT);
153             goto fail;
154         }
155         /* test error */
156         optlen = sizeof(ret);
157         if (getsockopt (fd, SOL_SOCKET, SO_ERROR, &ret, &optlen))
158             ret = AVUNERROR(ff_neterrno());
159         if (ret != 0) {
160             char errbuf[100];
161             ret = AVERROR(ret);
162             av_strerror(ret, errbuf, sizeof(errbuf));
163             av_log(h, AV_LOG_ERROR,
164                    "TCP connection to %s:%d failed: %s\n",
165                    hostname, port, errbuf);
166             goto fail;
167         }
168     }
169     h->is_streamed = 1;
170     s->fd = fd;
171     freeaddrinfo(ai);
172     return 0;
173
174  fail:
175     if (cur_ai->ai_next) {
176         /* Retry with the next sockaddr */
177         cur_ai = cur_ai->ai_next;
178         if (fd >= 0)
179             closesocket(fd);
180         goto restart;
181     }
182  fail1:
183     if (fd >= 0)
184         closesocket(fd);
185     freeaddrinfo(ai);
186     return ret;
187 }
188
189 static int tcp_read(URLContext *h, uint8_t *buf, int size)
190 {
191     TCPContext *s = h->priv_data;
192     int ret;
193
194     if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
195         ret = ff_network_wait_fd(s->fd, 0);
196         if (ret < 0)
197             return ret;
198     }
199     ret = recv(s->fd, buf, size, 0);
200     return ret < 0 ? ff_neterrno() : ret;
201 }
202
203 static int tcp_write(URLContext *h, const uint8_t *buf, int size)
204 {
205     TCPContext *s = h->priv_data;
206     int ret;
207
208     if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
209         ret = ff_network_wait_fd(s->fd, 1);
210         if (ret < 0)
211             return ret;
212     }
213     ret = send(s->fd, buf, size, 0);
214     return ret < 0 ? ff_neterrno() : ret;
215 }
216
217 static int tcp_shutdown(URLContext *h, int flags)
218 {
219     TCPContext *s = h->priv_data;
220     int how;
221
222     if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {
223         how = SHUT_RDWR;
224     } else if (flags & AVIO_FLAG_WRITE) {
225         how = SHUT_WR;
226     } else {
227         how = SHUT_RD;
228     }
229
230     return shutdown(s->fd, how);
231 }
232
233 static int tcp_close(URLContext *h)
234 {
235     TCPContext *s = h->priv_data;
236     closesocket(s->fd);
237     return 0;
238 }
239
240 static int tcp_get_file_handle(URLContext *h)
241 {
242     TCPContext *s = h->priv_data;
243     return s->fd;
244 }
245
246 URLProtocol ff_tcp_protocol = {
247     .name                = "tcp",
248     .url_open            = tcp_open,
249     .url_read            = tcp_read,
250     .url_write           = tcp_write,
251     .url_close           = tcp_close,
252     .url_get_file_handle = tcp_get_file_handle,
253     .url_shutdown        = tcp_shutdown,
254     .priv_data_size      = sizeof(TCPContext),
255     .flags               = URL_PROTOCOL_FLAG_NETWORK,
256 };