tcp.c
Go to the documentation of this file.
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) {
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)) {
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--) {
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 
241 {
242  TCPContext *s = h->priv_data;
243  return s->fd;
244 }
245 
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),
256 };
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:3173
int size
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:35
static int tcp_open(URLContext *h, const char *uri, int flags)
Definition: tcp.c:36
int is_streamed
true if streamed (no seek possible), default = false
Definition: url.h:48
AVIOInterruptCB interrupt_callback
Definition: url.h:50
#define AI_PASSIVE
Definition: network.h:143
int flags
Definition: url.h:46
#define freeaddrinfo
Definition: network.h:182
URLProtocol ff_tcp_protocol
Definition: tcp.c:246
uint8_t
miscellaneous OS support macros and functions.
static int flags
Definition: log.c:42
int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
Attempt to find a specific tag in a URL.
Definition: parseutils.c:604
static int tcp_read(URLContext *h, uint8_t *buf, int size)
Definition: tcp.c:189
#define closesocket
Definition: avserver.c:24
struct TCPContext TCPContext
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
static int tcp_close(URLContext *h)
Definition: tcp.c:233
static int tcp_shutdown(URLContext *h, int flags)
Definition: tcp.c:217
#define ff_neterrno()
Definition: network.h:62
Definition: tcp.c:31
int ff_socket_nonblock(int socket, int enable)
NULL
Definition: eval.c:52
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrup a blocking function associated with cb.
Definition: avio.c:369
Definition: url.h:41
void * priv_data
Definition: url.h:44
#define gai_strerror
Definition: network.h:188
int fd
Definition: tcp.c:32
misc parsing utilities
const char * name
Definition: url.h:54
int ai_socktype
Definition: network.h:104
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:23
#define getaddrinfo
Definition: network.h:181
Main libavformat public API header.
static int tcp_write(URLContext *h, const uint8_t *buf, int size)
Definition: tcp.c:203
int ai_flags
Definition: network.h:102
int ff_network_wait_fd(int fd, int write)
Definition: network.c:139
unbuffered private I/O API
static int tcp_get_file_handle(URLContext *h)
Definition: tcp.c:240
int ai_family
Definition: network.h:103