00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00027 #define _BSD_SOURCE
00028
00029 #include "avformat.h"
00030 #include "avio_internal.h"
00031 #include "libavutil/parseutils.h"
00032 #include "libavutil/avstring.h"
00033 #include <unistd.h>
00034 #include "internal.h"
00035 #include "network.h"
00036 #include "os_support.h"
00037 #include "url.h"
00038 #include <sys/time.h>
00039
00040 #ifndef IPV6_ADD_MEMBERSHIP
00041 #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
00042 #define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
00043 #endif
00044
00045 typedef struct {
00046 int udp_fd;
00047 int ttl;
00048 int buffer_size;
00049 int is_multicast;
00050 int local_port;
00051 int reuse_socket;
00052 struct sockaddr_storage dest_addr;
00053 int dest_addr_len;
00054 int is_connected;
00055 } UDPContext;
00056
00057 #define UDP_TX_BUF_SIZE 32768
00058 #define UDP_MAX_PKT_SIZE 65536
00059
00060 static int udp_set_multicast_ttl(int sockfd, int mcastTTL,
00061 struct sockaddr *addr)
00062 {
00063 #ifdef IP_MULTICAST_TTL
00064 if (addr->sa_family == AF_INET) {
00065 if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &mcastTTL, sizeof(mcastTTL)) < 0) {
00066 av_log(NULL, AV_LOG_ERROR, "setsockopt(IP_MULTICAST_TTL): %s\n", strerror(errno));
00067 return -1;
00068 }
00069 }
00070 #endif
00071 #if defined(IPPROTO_IPV6) && defined(IPV6_MULTICAST_HOPS)
00072 if (addr->sa_family == AF_INET6) {
00073 if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &mcastTTL, sizeof(mcastTTL)) < 0) {
00074 av_log(NULL, AV_LOG_ERROR, "setsockopt(IPV6_MULTICAST_HOPS): %s\n", strerror(errno));
00075 return -1;
00076 }
00077 }
00078 #endif
00079 return 0;
00080 }
00081
00082 static int udp_join_multicast_group(int sockfd, struct sockaddr *addr)
00083 {
00084 #ifdef IP_ADD_MEMBERSHIP
00085 if (addr->sa_family == AF_INET) {
00086 struct ip_mreq mreq;
00087
00088 mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
00089 mreq.imr_interface.s_addr= INADDR_ANY;
00090 if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
00091 av_log(NULL, AV_LOG_ERROR, "setsockopt(IP_ADD_MEMBERSHIP): %s\n", strerror(errno));
00092 return -1;
00093 }
00094 }
00095 #endif
00096 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)
00097 if (addr->sa_family == AF_INET6) {
00098 struct ipv6_mreq mreq6;
00099
00100 memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
00101 mreq6.ipv6mr_interface= 0;
00102 if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
00103 av_log(NULL, AV_LOG_ERROR, "setsockopt(IPV6_ADD_MEMBERSHIP): %s\n", strerror(errno));
00104 return -1;
00105 }
00106 }
00107 #endif
00108 return 0;
00109 }
00110
00111 static int udp_leave_multicast_group(int sockfd, struct sockaddr *addr)
00112 {
00113 #ifdef IP_DROP_MEMBERSHIP
00114 if (addr->sa_family == AF_INET) {
00115 struct ip_mreq mreq;
00116
00117 mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
00118 mreq.imr_interface.s_addr= INADDR_ANY;
00119 if (setsockopt(sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
00120 av_log(NULL, AV_LOG_ERROR, "setsockopt(IP_DROP_MEMBERSHIP): %s\n", strerror(errno));
00121 return -1;
00122 }
00123 }
00124 #endif
00125 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)
00126 if (addr->sa_family == AF_INET6) {
00127 struct ipv6_mreq mreq6;
00128
00129 memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
00130 mreq6.ipv6mr_interface= 0;
00131 if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
00132 av_log(NULL, AV_LOG_ERROR, "setsockopt(IPV6_DROP_MEMBERSHIP): %s\n", strerror(errno));
00133 return -1;
00134 }
00135 }
00136 #endif
00137 return 0;
00138 }
00139
00140 static struct addrinfo* udp_resolve_host(const char *hostname, int port,
00141 int type, int family, int flags)
00142 {
00143 struct addrinfo hints, *res = 0;
00144 int error;
00145 char sport[16];
00146 const char *node = 0, *service = "0";
00147
00148 if (port > 0) {
00149 snprintf(sport, sizeof(sport), "%d", port);
00150 service = sport;
00151 }
00152 if ((hostname) && (hostname[0] != '\0') && (hostname[0] != '?')) {
00153 node = hostname;
00154 }
00155 memset(&hints, 0, sizeof(hints));
00156 hints.ai_socktype = type;
00157 hints.ai_family = family;
00158 hints.ai_flags = flags;
00159 if ((error = getaddrinfo(node, service, &hints, &res))) {
00160 res = NULL;
00161 av_log(NULL, AV_LOG_ERROR, "udp_resolve_host: %s\n", gai_strerror(error));
00162 }
00163
00164 return res;
00165 }
00166
00167 static int udp_set_url(struct sockaddr_storage *addr,
00168 const char *hostname, int port)
00169 {
00170 struct addrinfo *res0;
00171 int addr_len;
00172
00173 res0 = udp_resolve_host(hostname, port, SOCK_DGRAM, AF_UNSPEC, 0);
00174 if (res0 == 0) return AVERROR(EIO);
00175 memcpy(addr, res0->ai_addr, res0->ai_addrlen);
00176 addr_len = res0->ai_addrlen;
00177 freeaddrinfo(res0);
00178
00179 return addr_len;
00180 }
00181
00182 static int udp_socket_create(UDPContext *s, struct sockaddr_storage *addr,
00183 int *addr_len, const char *localaddr)
00184 {
00185 int udp_fd = -1;
00186 struct addrinfo *res0 = NULL, *res = NULL;
00187 int family = AF_UNSPEC;
00188
00189 if (((struct sockaddr *) &s->dest_addr)->sa_family)
00190 family = ((struct sockaddr *) &s->dest_addr)->sa_family;
00191 res0 = udp_resolve_host(localaddr[0] ? localaddr : NULL, s->local_port,
00192 SOCK_DGRAM, family, AI_PASSIVE);
00193 if (res0 == 0)
00194 goto fail;
00195 for (res = res0; res; res=res->ai_next) {
00196 udp_fd = socket(res->ai_family, SOCK_DGRAM, 0);
00197 if (udp_fd > 0) break;
00198 av_log(NULL, AV_LOG_ERROR, "socket: %s\n", strerror(errno));
00199 }
00200
00201 if (udp_fd < 0)
00202 goto fail;
00203
00204 memcpy(addr, res->ai_addr, res->ai_addrlen);
00205 *addr_len = res->ai_addrlen;
00206
00207 freeaddrinfo(res0);
00208
00209 return udp_fd;
00210
00211 fail:
00212 if (udp_fd >= 0)
00213 closesocket(udp_fd);
00214 if(res0)
00215 freeaddrinfo(res0);
00216 return -1;
00217 }
00218
00219 static int udp_port(struct sockaddr_storage *addr, int addr_len)
00220 {
00221 char sbuf[sizeof(int)*3+1];
00222
00223 if (getnameinfo((struct sockaddr *)addr, addr_len, NULL, 0, sbuf, sizeof(sbuf), NI_NUMERICSERV) != 0) {
00224 av_log(NULL, AV_LOG_ERROR, "getnameinfo: %s\n", strerror(errno));
00225 return -1;
00226 }
00227
00228 return strtol(sbuf, NULL, 10);
00229 }
00230
00231
00247 int ff_udp_set_remote_url(URLContext *h, const char *uri)
00248 {
00249 UDPContext *s = h->priv_data;
00250 char hostname[256], buf[10];
00251 int port;
00252 const char *p;
00253
00254 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
00255
00256
00257 s->dest_addr_len = udp_set_url(&s->dest_addr, hostname, port);
00258 if (s->dest_addr_len < 0) {
00259 return AVERROR(EIO);
00260 }
00261 s->is_multicast = ff_is_multicast_address((struct sockaddr*) &s->dest_addr);
00262 p = strchr(uri, '?');
00263 if (p) {
00264 if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
00265 int was_connected = s->is_connected;
00266 s->is_connected = strtol(buf, NULL, 10);
00267 if (s->is_connected && !was_connected) {
00268 if (connect(s->udp_fd, (struct sockaddr *) &s->dest_addr,
00269 s->dest_addr_len)) {
00270 s->is_connected = 0;
00271 av_log(h, AV_LOG_ERROR, "connect: %s\n", strerror(errno));
00272 return AVERROR(EIO);
00273 }
00274 }
00275 }
00276 }
00277
00278 return 0;
00279 }
00280
00286 int ff_udp_get_local_port(URLContext *h)
00287 {
00288 UDPContext *s = h->priv_data;
00289 return s->local_port;
00290 }
00291
00297 static int udp_get_file_handle(URLContext *h)
00298 {
00299 UDPContext *s = h->priv_data;
00300 return s->udp_fd;
00301 }
00302
00303
00304
00305 static int udp_open(URLContext *h, const char *uri, int flags)
00306 {
00307 char hostname[1024], localaddr[1024] = "";
00308 int port, udp_fd = -1, tmp, bind_ret = -1;
00309 UDPContext *s = h->priv_data;
00310 int is_output;
00311 const char *p;
00312 char buf[256];
00313 struct sockaddr_storage my_addr;
00314 int len;
00315 int reuse_specified = 0;
00316
00317 h->is_streamed = 1;
00318 h->max_packet_size = 1472;
00319
00320 is_output = !(flags & AVIO_FLAG_READ);
00321
00322 s->ttl = 16;
00323 s->buffer_size = is_output ? UDP_TX_BUF_SIZE : UDP_MAX_PKT_SIZE;
00324
00325 p = strchr(uri, '?');
00326 if (p) {
00327 if (av_find_info_tag(buf, sizeof(buf), "reuse", p)) {
00328 char *endptr = NULL;
00329 s->reuse_socket = strtol(buf, &endptr, 10);
00330
00331 if (buf == endptr)
00332 s->reuse_socket = 1;
00333 reuse_specified = 1;
00334 }
00335 if (av_find_info_tag(buf, sizeof(buf), "ttl", p)) {
00336 s->ttl = strtol(buf, NULL, 10);
00337 }
00338 if (av_find_info_tag(buf, sizeof(buf), "localport", p)) {
00339 s->local_port = strtol(buf, NULL, 10);
00340 }
00341 if (av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
00342 h->max_packet_size = strtol(buf, NULL, 10);
00343 }
00344 if (av_find_info_tag(buf, sizeof(buf), "buffer_size", p)) {
00345 s->buffer_size = strtol(buf, NULL, 10);
00346 }
00347 if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
00348 s->is_connected = strtol(buf, NULL, 10);
00349 }
00350 if (av_find_info_tag(buf, sizeof(buf), "localaddr", p)) {
00351 av_strlcpy(localaddr, buf, sizeof(localaddr));
00352 }
00353 }
00354
00355
00356 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
00357
00358
00359 if (hostname[0] == '\0' || hostname[0] == '?') {
00360
00361 if (!(flags & AVIO_FLAG_READ))
00362 goto fail;
00363 } else {
00364 if (ff_udp_set_remote_url(h, uri) < 0)
00365 goto fail;
00366 }
00367
00368 if ((s->is_multicast || !s->local_port) && (h->flags & AVIO_FLAG_READ))
00369 s->local_port = port;
00370 udp_fd = udp_socket_create(s, &my_addr, &len, localaddr);
00371 if (udp_fd < 0)
00372 goto fail;
00373
00374
00375
00376
00377 if (s->reuse_socket || (s->is_multicast && !reuse_specified)) {
00378 s->reuse_socket = 1;
00379 if (setsockopt (udp_fd, SOL_SOCKET, SO_REUSEADDR, &(s->reuse_socket), sizeof(s->reuse_socket)) != 0)
00380 goto fail;
00381 }
00382
00383
00384
00385 if (s->is_multicast && (h->flags & AVIO_FLAG_READ)) {
00386 bind_ret = bind(udp_fd,(struct sockaddr *)&s->dest_addr, len);
00387 }
00388
00389
00390 if (bind_ret < 0 && bind(udp_fd,(struct sockaddr *)&my_addr, len) < 0)
00391 goto fail;
00392
00393 len = sizeof(my_addr);
00394 getsockname(udp_fd, (struct sockaddr *)&my_addr, &len);
00395 s->local_port = udp_port(&my_addr, len);
00396
00397 if (s->is_multicast) {
00398 if (!(h->flags & AVIO_FLAG_READ)) {
00399
00400 if (udp_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr) < 0)
00401 goto fail;
00402 } else {
00403
00404 if (udp_join_multicast_group(udp_fd, (struct sockaddr *)&s->dest_addr) < 0)
00405 goto fail;
00406 }
00407 }
00408
00409 if (is_output) {
00410
00411 tmp = s->buffer_size;
00412 if (setsockopt(udp_fd, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)) < 0) {
00413 av_log(h, AV_LOG_ERROR, "setsockopt(SO_SNDBUF): %s\n", strerror(errno));
00414 goto fail;
00415 }
00416 } else {
00417
00418
00419 tmp = s->buffer_size;
00420 if (setsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, sizeof(tmp)) < 0) {
00421 av_log(h, AV_LOG_WARNING, "setsockopt(SO_RECVBUF): %s\n", strerror(errno));
00422 }
00423
00424 ff_socket_nonblock(udp_fd, 1);
00425 }
00426 if (s->is_connected) {
00427 if (connect(udp_fd, (struct sockaddr *) &s->dest_addr, s->dest_addr_len)) {
00428 av_log(h, AV_LOG_ERROR, "connect: %s\n", strerror(errno));
00429 goto fail;
00430 }
00431 }
00432
00433 s->udp_fd = udp_fd;
00434 return 0;
00435 fail:
00436 if (udp_fd >= 0)
00437 closesocket(udp_fd);
00438 return AVERROR(EIO);
00439 }
00440
00441 static int udp_read(URLContext *h, uint8_t *buf, int size)
00442 {
00443 UDPContext *s = h->priv_data;
00444 int ret;
00445
00446 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
00447 ret = ff_network_wait_fd(s->udp_fd, 0);
00448 if (ret < 0)
00449 return ret;
00450 }
00451 ret = recv(s->udp_fd, buf, size, 0);
00452 return ret < 0 ? ff_neterrno() : ret;
00453 }
00454
00455 static int udp_write(URLContext *h, const uint8_t *buf, int size)
00456 {
00457 UDPContext *s = h->priv_data;
00458 int ret;
00459
00460 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
00461 ret = ff_network_wait_fd(s->udp_fd, 1);
00462 if (ret < 0)
00463 return ret;
00464 }
00465
00466 if (!s->is_connected) {
00467 ret = sendto (s->udp_fd, buf, size, 0,
00468 (struct sockaddr *) &s->dest_addr,
00469 s->dest_addr_len);
00470 } else
00471 ret = send(s->udp_fd, buf, size, 0);
00472
00473 return ret < 0 ? ff_neterrno() : ret;
00474 }
00475
00476 static int udp_close(URLContext *h)
00477 {
00478 UDPContext *s = h->priv_data;
00479
00480 if (s->is_multicast && (h->flags & AVIO_FLAG_READ))
00481 udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr);
00482 closesocket(s->udp_fd);
00483 return 0;
00484 }
00485
00486 URLProtocol ff_udp_protocol = {
00487 .name = "udp",
00488 .url_open = udp_open,
00489 .url_read = udp_read,
00490 .url_write = udp_write,
00491 .url_close = udp_close,
00492 .url_get_file_handle = udp_get_file_handle,
00493 .priv_data_size = sizeof(UDPContext),
00494 .flags = URL_PROTOCOL_FLAG_NETWORK,
00495 };