FFmpeg: libavformat/tcp.c Source File

FFmpeg

[フレーム]

libavformat

tcp.c

Go to the documentation of this file.

1 /*

2 * TCP protocol

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"

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

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 int tcp_nodelay;

45 #if !HAVE_WINSOCK2_H

46 int tcp_mss;

47 #endif /* !HAVE_WINSOCK2_H */

48 } TCPContext;

50 #define OFFSET(x) offsetof(TCPContext, x)

51 #define D AV_OPT_FLAG_DECODING_PARAM

52 #define E AV_OPT_FLAG_ENCODING_PARAM

53 static const AVOption options[] = {

54 { "listen", "Listen for incoming connections", OFFSET(listen), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, .flags = D|E },

55 { "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 },

56 { "listen_timeout", "Connection awaiting timeout (in milliseconds)", OFFSET(listen_timeout), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },

57 { "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 },

58 { "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 },

59 { "tcp_nodelay", "Use TCP_NODELAY to disable nagle's algorithm", OFFSET(tcp_nodelay), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = D|E },

60 #if !HAVE_WINSOCK2_H

61 { "tcp_mss", "Maximum segment size for outgoing TCP packets", OFFSET(tcp_mss), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },

62 #endif /* !HAVE_WINSOCK2_H */

63 { NULL }

64 };

66 static const AVClass tcp_class = {

67 .class_name = "tcp",

68 .item_name = av_default_item_name,

69 .option = options,

70 .version = LIBAVUTIL_VERSION_INT,

71 };

73 static void customize_fd(void *ctx, int fd)

74 {

75 TCPContext *s = ctx;

76 /* Set the socket's send or receive buffer sizes, if specified.

77 If unspecified or setting fails, system default is used. */

78 if (s->recv_buffer_size > 0) {

79 if (setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &s->recv_buffer_size, sizeof (s->recv_buffer_size))) {

80 ff_log_net_error(ctx, AV_LOG_WARNING, "setsockopt(SO_RCVBUF)");

81 }

82 }

83 if (s->send_buffer_size > 0) {

84 if (setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &s->send_buffer_size, sizeof (s->send_buffer_size))) {

85 ff_log_net_error(ctx, AV_LOG_WARNING, "setsockopt(SO_SNDBUF)");

86 }

87 }

88 if (s->tcp_nodelay > 0) {

89 if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &s->tcp_nodelay, sizeof (s->tcp_nodelay))) {

90 ff_log_net_error(ctx, AV_LOG_WARNING, "setsockopt(TCP_NODELAY)");

91 }

92 }

93 #if !HAVE_WINSOCK2_H

94 if (s->tcp_mss > 0) {

95 if (setsockopt (fd, IPPROTO_TCP, TCP_MAXSEG, &s->tcp_mss, sizeof (s->tcp_mss))) {

96 ff_log_net_error(ctx, AV_LOG_WARNING, "setsockopt(TCP_MAXSEG)");

97 }

98 }

99 #endif /* !HAVE_WINSOCK2_H */

100 }

101

102 /* return non zero if error */

103 static int tcp_open(URLContext *h, const char *uri, int flags)

104 {

105 struct addrinfo hints = { 0 }, *ai, *cur_ai;

106 int port, fd = -1;

107 TCPContext *s = h->priv_data;

108 const char *p;

109 char buf[256];

110 int ret;

111 char hostname[1024],proto[1024],path[1024];

112 char portstr[10];

113 s->open_timeout = 5000000;

114

115 av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname),

116 &port, path, sizeof(path), uri);

117 if (strcmp(proto, "tcp"))

118 return AVERROR(EINVAL);

119 if (port <= 0 || port >= 65536) {

120 av_log(h, AV_LOG_ERROR, "Port missing in uri\n");

121 return AVERROR(EINVAL);

122 }

123 p = strchr(uri, '?');

124 if (p) {

125 if (av_find_info_tag(buf, sizeof(buf), "listen", p)) {

126 char *endptr = NULL;

127 s->listen = strtol(buf, &endptr, 10);

128 /* assume if no digits were found it is a request to enable it */

129 if (buf == endptr)

130 s->listen = 1;

131 }

132 if (av_find_info_tag(buf, sizeof(buf), "timeout", p)) {

133 s->rw_timeout = strtol(buf, NULL, 10);

134 }

135 if (av_find_info_tag(buf, sizeof(buf), "listen_timeout", p)) {

136 s->listen_timeout = strtol(buf, NULL, 10);

137 }

138 }

139 if (s->rw_timeout >= 0) {

140 s->open_timeout =

141 h->rw_timeout = s->rw_timeout;

142 }

143 hints.ai_family = AF_UNSPEC;

144 hints.ai_socktype = SOCK_STREAM;

145 snprintf(portstr, sizeof(portstr), "%d", port);

146 if (s->listen)

147 hints.ai_flags |= AI_PASSIVE;

148 if (!hostname[0])

149 ret = getaddrinfo(NULL, portstr, &hints, &ai);

150 else

151 ret = getaddrinfo(hostname, portstr, &hints, &ai);

152 if (ret) {

153 av_log(h, AV_LOG_ERROR,

154 "Failed to resolve hostname %s: %s\n",

155 hostname, gai_strerror(ret));

156 return AVERROR(EIO);

157 }

158

159 cur_ai = ai;

160

161 #if HAVE_STRUCT_SOCKADDR_IN6

162 // workaround for IOS9 getaddrinfo in IPv6 only network use hardcode IPv4 address can not resolve port number.

163 if (cur_ai->ai_family == AF_INET6){

164 struct sockaddr_in6 * sockaddr_v6 = (struct sockaddr_in6 *)cur_ai->ai_addr;

165 if (!sockaddr_v6->sin6_port){

166 sockaddr_v6->sin6_port = htons(port);

167 }

168 }

169 #endif

170

171 if (s->listen > 0) {

172 while (cur_ai && fd < 0) {

173 fd = ff_socket(cur_ai->ai_family,

174 cur_ai->ai_socktype,

175 cur_ai->ai_protocol);

176 if (fd < 0) {

177 ret = ff_neterrno();

178 cur_ai = cur_ai->ai_next;

179 }

180 }

181 if (fd < 0)

182 goto fail1;

183 customize_fd(s, fd);

184 }

185

186 if (s->listen == 2) {

187 // multi-client

188 if ((ret = ff_listen(fd, cur_ai->ai_addr, cur_ai->ai_addrlen)) < 0)

189 goto fail1;

190 } else if (s->listen == 1) {

191 // single client

192 if ((ret = ff_listen_bind(fd, cur_ai->ai_addr, cur_ai->ai_addrlen,

193 s->listen_timeout, h)) < 0)

194 goto fail1;

195 // Socket descriptor already closed here. Safe to overwrite to client one.

196 fd = ret;

197 } else {

198 ret = ff_connect_parallel(ai, s->open_timeout / 1000, 3, h, &fd, customize_fd, s);

199 if (ret < 0)

200 goto fail1;

201 }

202

203 h->is_streamed = 1;

204 s->fd = fd;

205

206 freeaddrinfo(ai);

207 return 0;

208

209 fail1:

210 if (fd >= 0)

211 closesocket(fd);

212 freeaddrinfo(ai);

213 return ret;

214 }

215

216 static int tcp_accept(URLContext *s, URLContext **c)

217 {

218 TCPContext *sc = s->priv_data;

219 TCPContext *cc;

220 int ret;

221 av_assert0(sc->listen);

222 if ((ret = ffurl_alloc(c, s->filename, s->flags, &s->interrupt_callback)) < 0)

223 return ret;

224 cc = (*c)->priv_data;

225 ret = ff_accept(sc->fd, sc->listen_timeout, s);

226 if (ret < 0) {

227 ffurl_closep(c);

228 return ret;

229 }

230 cc->fd = ret;

231 return 0;

232 }

233

234 static int tcp_read(URLContext *h, uint8_t *buf, int size)

235 {

236 TCPContext *s = h->priv_data;

237 int ret;

238

239 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {

240 ret = ff_network_wait_fd_timeout(s->fd, 0, h->rw_timeout, &h->interrupt_callback);

241 if (ret)

242 return ret;

243 }

244 ret = recv(s->fd, buf, size, 0);

245 if (ret == 0)

246 return AVERROR_EOF;

247 return ret < 0 ? ff_neterrno() : ret;

248 }

249

250 static int tcp_write(URLContext *h, const uint8_t *buf, int size)

251 {

252 TCPContext *s = h->priv_data;

253 int ret;

254

255 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {

256 ret = ff_network_wait_fd_timeout(s->fd, 1, h->rw_timeout, &h->interrupt_callback);

257 if (ret)

258 return ret;

259 }

260 ret = send(s->fd, buf, size, MSG_NOSIGNAL);

261 return ret < 0 ? ff_neterrno() : ret;

262 }

263

264 static int tcp_shutdown(URLContext *h, int flags)

265 {

266 TCPContext *s = h->priv_data;

267 int how;

268

269 if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {

270 how = SHUT_RDWR;

271 } else if (flags & AVIO_FLAG_WRITE) {

272 how = SHUT_WR;

273 } else {

274 how = SHUT_RD;

275 }

276

277 return shutdown(s->fd, how);

278 }

279

280 static int tcp_close(URLContext *h)

281 {

282 TCPContext *s = h->priv_data;

283 closesocket(s->fd);

284 return 0;

285 }

286

287 static int tcp_get_file_handle(URLContext *h)

288 {

289 TCPContext *s = h->priv_data;

290 return s->fd;

291 }

292

293 static int tcp_get_window_size(URLContext *h)

294 {

295 TCPContext *s = h->priv_data;

296 int avail;

297 socklen_t avail_len = sizeof(avail);

298

299 #if HAVE_WINSOCK2_H

300 /* SO_RCVBUF with winsock only reports the actual TCP window size when

301 auto-tuning has been disabled via setting SO_RCVBUF */

302 if (s->recv_buffer_size < 0) {

303 return AVERROR(ENOSYS);

304 }

305 #endif

306

307 if (getsockopt(s->fd, SOL_SOCKET, SO_RCVBUF, &avail, &avail_len)) {

308 return ff_neterrno();

309 }

310 return avail;

311 }

312

313 const URLProtocol ff_tcp_protocol = {

314 .name = "tcp",

315 .url_open = tcp_open,

316 .url_accept = tcp_accept,

317 .url_read = tcp_read,

318 .url_write = tcp_write,

319 .url_close = tcp_close,

320 .url_get_file_handle = tcp_get_file_handle,

321 .url_get_short_seek = tcp_get_window_size,

322 .url_shutdown = tcp_shutdown,

323 .priv_data_size = sizeof(TCPContext),

324 .flags = URL_PROTOCOL_FLAG_NETWORK,

325 .priv_data_class = &tcp_class,

326 };

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:200

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

av_find_info_tag

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:751

#define E

Definition: tcp.c:52

tcp_accept

static int tcp_accept(URLContext *s, URLContext **c)

Definition: tcp.c:216

URL_PROTOCOL_FLAG_NETWORK

#define URL_PROTOCOL_FLAG_NETWORK

Definition: url.h:34

TCPContext::tcp_mss

int tcp_mss

Definition: tcp.c:46

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:55

OFFSET

#define OFFSET(x)

Definition: tcp.c:50

tcp_write

static int tcp_write(URLContext *h, const uint8_t *buf, int size)

Definition: tcp.c:250

AVOption

AVOption.

Definition: opt.h:248

ff_log_net_error

void ff_log_net_error(void *ctx, int level, const char *prefix)

Definition: network.c:581

ff_socket

int ff_socket(int af, int type, int proto)

Definition: network.c:183

URLProtocol

Definition: url.h:54

os_support.h

freeaddrinfo

#define freeaddrinfo

Definition: network.h:218

ff_listen_bind

int ff_listen_bind(int fd, const struct sockaddr *addr, socklen_t addrlen, int timeout, URLContext *h)

Bind to a file descriptor and poll for a connection.

Definition: network.c:246

avassert.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:194

TCPContext::rw_timeout

int rw_timeout

Definition: tcp.c:40

ff_listen

int ff_listen(int fd, const struct sockaddr *addr, socklen_t addrlen)

Bind to a file descriptor to an address without accepting connections.

Definition: network.c:210

TCPContext::fd

int fd

Definition: tcp.c:37

#define s(width, name)

Definition: cbs_vp9.c:257

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

AVIO_FLAG_WRITE

#define AVIO_FLAG_WRITE

write-only

Definition: avio.h:675

tcp_open

static int tcp_open(URLContext *h, const char *uri, int flags)

Definition: tcp.c:103

ctx

AVFormatContext * ctx

Definition: movenc.c:48

TCPContext::listen

int listen

Definition: tcp.c:38

if(ret)

Definition: filter_design.txt:179

tcp_read

static int tcp_read(URLContext *h, uint8_t *buf, int size)

Definition: tcp.c:234

internal.h

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

NULL

#define NULL

Definition: coverity.c:32

TCPContext::send_buffer_size

int send_buffer_size

Definition: tcp.c:43

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:235

parseutils.h

ff_network_wait_fd_timeout

int ff_network_wait_fd_timeout(int fd, int write, int64_t timeout, AVIOInterruptCB *int_cb)

This works similarly to ff_network_wait_fd, but waits up to 'timeout' microseconds Uses ff_network_wa...

Definition: network.c:78

time.h

ff_neterrno

#define ff_neterrno()

Definition: network.h:68

options

static const AVOption options[]

Definition: tcp.c:53

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

tcp_close

static int tcp_close(URLContext *h)

Definition: tcp.c:280

ff_tcp_protocol

const URLProtocol ff_tcp_protocol

Definition: tcp.c:313

addrinfo::ai_family

int ai_family

Definition: network.h:139

TCPContext

Definition: tcp.c:35

ff_accept

int ff_accept(int fd, int timeout, URLContext *h)

Poll for a single connection on the passed file descriptor.

Definition: network.c:228

size

int size

Definition: twinvq_data.h:10344

URLProtocol::name

const char * name

Definition: url.h:55

tcp_get_file_handle

static int tcp_get_file_handle(URLContext *h)

Definition: tcp.c:287

tcp_get_window_size

static int tcp_get_window_size(URLContext *h)

Definition: tcp.c:293

gai_strerror

#define gai_strerror

Definition: network.h:225

TCPContext::tcp_nodelay

int tcp_nodelay

Definition: tcp.c:44

ffurl_alloc

int ffurl_alloc(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb)

Create a URLContext for accessing to the resource indicated by url, but do not initiate the connectio...

Definition: avio.c:296

getaddrinfo

#define getaddrinfo

Definition: network.h:217

TCPContext::recv_buffer_size

int recv_buffer_size

Definition: tcp.c:42

TCPContext::listen_timeout

int listen_timeout

Definition: tcp.c:41

URLContext

Definition: url.h:38

ff_connect_parallel

int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address, int parallel, URLContext *h, int *fd, void(*customize_fd)(void *, int), void *customize_ctx)

Connect to any of the given addrinfo addresses, with multiple attempts running in parallel.

Definition: network.c:403

TCPContext::open_timeout

int open_timeout

Definition: tcp.c:39

av_url_split

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:4799

url.h

uint8_t

Definition: audio_convert.c:194

#define D

Definition: tcp.c:51

tcp_shutdown

static int tcp_shutdown(URLContext *h, int flags)

Definition: tcp.c:264

ffurl_closep

int ffurl_closep(URLContext **hh)