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 #define _DARWIN_C_SOURCE
00029 #include "avformat.h"
00030 #include "libavutil/parseutils.h"
00031 #include <unistd.h>
00032 #include "internal.h"
00033 #include "network.h"
00034 #include "os_support.h"
00035 #if HAVE_POLL_H
00036 #include <poll.h>
00037 #endif
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,
00183 struct sockaddr_storage *addr, int *addr_len)
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(0, s->local_port, SOCK_DGRAM, family, AI_PASSIVE);
00192 if (res0 == 0)
00193 goto fail;
00194 for (res = res0; res; res=res->ai_next) {
00195 udp_fd = socket(res->ai_family, SOCK_DGRAM, 0);
00196 if (udp_fd > 0) break;
00197 av_log(NULL, AV_LOG_ERROR, "socket: %s\n", strerror(errno));
00198 }
00199
00200 if (udp_fd < 0)
00201 goto fail;
00202
00203 memcpy(addr, res->ai_addr, res->ai_addrlen);
00204 *addr_len = res->ai_addrlen;
00205
00206 freeaddrinfo(res0);
00207
00208 return udp_fd;
00209
00210 fail:
00211 if (udp_fd >= 0)
00212 closesocket(udp_fd);
00213 if(res0)
00214 freeaddrinfo(res0);
00215 return -1;
00216 }
00217
00218 static int udp_port(struct sockaddr_storage *addr, int addr_len)
00219 {
00220 char sbuf[sizeof(int)*3+1];
00221
00222 if (getnameinfo((struct sockaddr *)addr, addr_len, NULL, 0, sbuf, sizeof(sbuf), NI_NUMERICSERV) != 0) {
00223 av_log(NULL, AV_LOG_ERROR, "getnameinfo: %s\n", strerror(errno));
00224 return -1;
00225 }
00226
00227 return strtol(sbuf, NULL, 10);
00228 }
00229
00230
00246 int udp_set_remote_url(URLContext *h, const char *uri)
00247 {
00248 UDPContext *s = h->priv_data;
00249 char hostname[256], buf[10];
00250 int port;
00251 const char *p;
00252
00253 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
00254
00255
00256 s->dest_addr_len = udp_set_url(&s->dest_addr, hostname, port);
00257 if (s->dest_addr_len < 0) {
00258 return AVERROR(EIO);
00259 }
00260 s->is_multicast = ff_is_multicast_address((struct sockaddr*) &s->dest_addr);
00261 p = strchr(uri, '?');
00262 if (p) {
00263 if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
00264 int was_connected = s->is_connected;
00265 s->is_connected = strtol(buf, NULL, 10);
00266 if (s->is_connected && !was_connected) {
00267 if (connect(s->udp_fd, (struct sockaddr *) &s->dest_addr,
00268 s->dest_addr_len)) {
00269 s->is_connected = 0;
00270 av_log(NULL, AV_LOG_ERROR, "connect: %s\n", strerror(errno));
00271 return AVERROR(EIO);
00272 }
00273 }
00274 }
00275 }
00276
00277 return 0;
00278 }
00279
00285 int udp_get_local_port(URLContext *h)
00286 {
00287 UDPContext *s = h->priv_data;
00288 return s->local_port;
00289 }
00290
00296 #if !FF_API_UDP_GET_FILE
00297 static
00298 #endif
00299 int udp_get_file_handle(URLContext *h)
00300 {
00301 UDPContext *s = h->priv_data;
00302 return s->udp_fd;
00303 }
00304
00305
00306
00307 static int udp_open(URLContext *h, const char *uri, int flags)
00308 {
00309 char hostname[1024];
00310 int port, udp_fd = -1, tmp, bind_ret = -1;
00311 UDPContext *s = NULL;
00312 int is_output;
00313 const char *p;
00314 char buf[256];
00315 struct sockaddr_storage my_addr;
00316 int len;
00317 int reuse_specified = 0;
00318
00319 h->is_streamed = 1;
00320 h->max_packet_size = 1472;
00321
00322 is_output = (flags & URL_WRONLY);
00323
00324 s = av_mallocz(sizeof(UDPContext));
00325 if (!s)
00326 return AVERROR(ENOMEM);
00327
00328 h->priv_data = s;
00329 s->ttl = 16;
00330 s->buffer_size = is_output ? UDP_TX_BUF_SIZE : UDP_MAX_PKT_SIZE;
00331
00332 p = strchr(uri, '?');
00333 if (p) {
00334 if (av_find_info_tag(buf, sizeof(buf), "reuse", p)) {
00335 const char *endptr=NULL;
00336 s->reuse_socket = strtol(buf, &endptr, 10);
00337
00338 if (buf == endptr)
00339 s->reuse_socket = 1;
00340 reuse_specified = 1;
00341 }
00342 if (av_find_info_tag(buf, sizeof(buf), "ttl", p)) {
00343 s->ttl = strtol(buf, NULL, 10);
00344 }
00345 if (av_find_info_tag(buf, sizeof(buf), "localport", p)) {
00346 s->local_port = strtol(buf, NULL, 10);
00347 }
00348 if (av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
00349 h->max_packet_size = strtol(buf, NULL, 10);
00350 }
00351 if (av_find_info_tag(buf, sizeof(buf), "buffer_size", p)) {
00352 s->buffer_size = strtol(buf, NULL, 10);
00353 }
00354 if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
00355 s->is_connected = strtol(buf, NULL, 10);
00356 }
00357 }
00358
00359
00360 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
00361
00362
00363 if (hostname[0] == '\0' || hostname[0] == '?') {
00364
00365 if (flags & URL_WRONLY)
00366 goto fail;
00367 } else {
00368 if (udp_set_remote_url(h, uri) < 0)
00369 goto fail;
00370 }
00371
00372 if (s->is_multicast && !(h->flags & URL_WRONLY))
00373 s->local_port = port;
00374 udp_fd = udp_socket_create(s, &my_addr, &len);
00375 if (udp_fd < 0)
00376 goto fail;
00377
00378
00379
00380
00381 if (s->reuse_socket || (s->is_multicast && !reuse_specified)) {
00382 s->reuse_socket = 1;
00383 if (setsockopt (udp_fd, SOL_SOCKET, SO_REUSEADDR, &(s->reuse_socket), sizeof(s->reuse_socket)) != 0)
00384 goto fail;
00385 }
00386
00387
00388
00389 if (s->is_multicast && !(h->flags & URL_WRONLY)) {
00390 bind_ret = bind(udp_fd,(struct sockaddr *)&s->dest_addr, len);
00391 }
00392
00393
00394 if (bind_ret < 0 && bind(udp_fd,(struct sockaddr *)&my_addr, len) < 0)
00395 goto fail;
00396
00397 len = sizeof(my_addr);
00398 getsockname(udp_fd, (struct sockaddr *)&my_addr, &len);
00399 s->local_port = udp_port(&my_addr, len);
00400
00401 if (s->is_multicast) {
00402 if (h->flags & URL_WRONLY) {
00403
00404 if (udp_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr) < 0)
00405 goto fail;
00406 } else {
00407
00408 if (udp_join_multicast_group(udp_fd, (struct sockaddr *)&s->dest_addr) < 0)
00409 goto fail;
00410 }
00411 }
00412
00413 if (is_output) {
00414
00415 tmp = s->buffer_size;
00416 if (setsockopt(udp_fd, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)) < 0) {
00417 av_log(NULL, AV_LOG_ERROR, "setsockopt(SO_SNDBUF): %s\n", strerror(errno));
00418 goto fail;
00419 }
00420 } else {
00421
00422
00423 tmp = s->buffer_size;
00424 if (setsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, sizeof(tmp)) < 0) {
00425 av_log(NULL, AV_LOG_WARNING, "setsockopt(SO_RECVBUF): %s\n", strerror(errno));
00426 }
00427
00428 ff_socket_nonblock(udp_fd, 1);
00429 }
00430 if (s->is_connected) {
00431 if (connect(udp_fd, (struct sockaddr *) &s->dest_addr, s->dest_addr_len)) {
00432 av_log(NULL, AV_LOG_ERROR, "connect: %s\n", strerror(errno));
00433 goto fail;
00434 }
00435 }
00436
00437 s->udp_fd = udp_fd;
00438 return 0;
00439 fail:
00440 if (udp_fd >= 0)
00441 closesocket(udp_fd);
00442 av_free(s);
00443 return AVERROR(EIO);
00444 }
00445
00446 static int udp_read(URLContext *h, uint8_t *buf, int size)
00447 {
00448 UDPContext *s = h->priv_data;
00449 struct pollfd p = {s->udp_fd, POLLIN, 0};
00450 int len;
00451 int ret;
00452
00453 for(;;) {
00454 if (url_interrupt_cb())
00455 return AVERROR(EINTR);
00456 ret = poll(&p, 1, 100);
00457 if (ret < 0) {
00458 if (ff_neterrno() == AVERROR(EINTR))
00459 continue;
00460 return AVERROR(EIO);
00461 }
00462 if (!(ret == 1 && p.revents & POLLIN))
00463 continue;
00464 len = recv(s->udp_fd, buf, size, 0);
00465 if (len < 0) {
00466 if (ff_neterrno() != AVERROR(EAGAIN) &&
00467 ff_neterrno() != AVERROR(EINTR))
00468 return AVERROR(EIO);
00469 } else {
00470 break;
00471 }
00472 }
00473 return len;
00474 }
00475
00476 static int udp_write(URLContext *h, const uint8_t *buf, int size)
00477 {
00478 UDPContext *s = h->priv_data;
00479 int ret;
00480
00481 for(;;) {
00482 if (!s->is_connected) {
00483 ret = sendto (s->udp_fd, buf, size, 0,
00484 (struct sockaddr *) &s->dest_addr,
00485 s->dest_addr_len);
00486 } else
00487 ret = send(s->udp_fd, buf, size, 0);
00488 if (ret < 0) {
00489 if (ff_neterrno() != AVERROR(EINTR) &&
00490 ff_neterrno() != AVERROR(EAGAIN))
00491 return ff_neterrno();
00492 } else {
00493 break;
00494 }
00495 }
00496 return size;
00497 }
00498
00499 static int udp_close(URLContext *h)
00500 {
00501 UDPContext *s = h->priv_data;
00502
00503 if (s->is_multicast && !(h->flags & URL_WRONLY))
00504 udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr);
00505 closesocket(s->udp_fd);
00506 av_free(s);
00507 return 0;
00508 }
00509
00510 URLProtocol ff_udp_protocol = {
00511 "udp",
00512 udp_open,
00513 udp_read,
00514 udp_write,
00515 NULL,
00516 udp_close,
00517 .url_get_file_handle = udp_get_file_handle,
00518 };