libavformat/udp.c

   1 /*
   2  * UDP prototype streaming system
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
   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 <unistd.h>
  23 #include <sys/types.h>
  24 #include <sys/socket.h>
  25 #include <netinet/in.h>
  26 #ifndef __BEOS__
  27 # include <arpa/inet.h>
  28 #else
  29 # include "barpainet.h"
  30 #endif
  31 #include <netdb.h>
  32
  33 #ifndef IPV6_ADD_MEMBERSHIP
  34 #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
  35 #define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
  36 #endif
  37
  38 typedef struct {
  39     int udp_fd;
  40     int ttl;
  41     int is_multicast;
  42     int local_port;
  43     int reuse_socket;
  44 #ifndef CONFIG_IPV6
  45     struct ip_mreq mreq;
  46     struct sockaddr_in dest_addr;
  47 #else
  48     struct sockaddr_storage dest_addr;
  49     size_t dest_addr_len;
  50 #endif
  51 } UDPContext;
  52
  53 #define UDP_TX_BUF_SIZE 32768
  54
  55 #ifdef CONFIG_IPV6
  56
  57 static int udp_ipv6_is_multicast_address(const struct sockaddr *addr) {
  58     if (addr->sa_family == AF_INET)
  59         return IN_MULTICAST(ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr));
  60     if (addr->sa_family == AF_INET6)
  61         return IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *)addr)->sin6_addr);
  62     return -1;
  63 }
  64
  65 static int udp_ipv6_set_multicast_ttl(int sockfd, int mcastTTL, struct sockaddr *addr) {
  66     if (addr->sa_family == AF_INET) {
  67         if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &mcastTTL, sizeof(mcastTTL)) < 0) {
  68             perror("setsockopt(IP_MULTICAST_TTL)");
  69             return -1;
  70         }
  71     }
  72     if (addr->sa_family == AF_INET6) {
  73         if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &mcastTTL, sizeof(mcastTTL)) < 0) {
  74             perror("setsockopt(IPV6_MULTICAST_HOPS)");
  75             return -1;
  76         }
  77     }
  78     return 0;
  79 }
  80
  81 static int udp_ipv6_join_multicast_group(int sockfd, struct sockaddr *addr) {
  82     struct ip_mreq   mreq;
  83     struct ipv6_mreq mreq6;
  84     if (addr->sa_family == AF_INET) {
  85         mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
  86         mreq.imr_interface.s_addr= INADDR_ANY;
  87         if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
  88             perror("setsockopt(IP_ADD_MEMBERSHIP)");
  89             return -1;
  90         }
  91     }
  92     if (addr->sa_family == AF_INET6) {
  93         memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
  94         mreq6.ipv6mr_interface= 0;
  95         if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
  96             perror("setsockopt(IPV6_ADD_MEMBERSHIP)");
  97             return -1;
  98         }
  99     }
 100     return 0;
 101 }
 102
 103 static int udp_ipv6_leave_multicast_group(int sockfd, struct sockaddr *addr) {
 104     struct ip_mreq   mreq;
 105     struct ipv6_mreq mreq6;
 106     if (addr->sa_family == AF_INET) {
 107         mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
 108         mreq.imr_interface.s_addr= INADDR_ANY;
 109         if (setsockopt(sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
 110             perror("setsockopt(IP_DROP_MEMBERSHIP)");
 111             return -1;
 112         }
 113     }
 114     if (addr->sa_family == AF_INET6) {
 115         memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
 116         mreq6.ipv6mr_interface= 0;
 117         if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
 118             perror("setsockopt(IPV6_DROP_MEMBERSHIP)");
 119             return -1;
 120         }
 121     }
 122     return 0;
 123 }
 124
 125 static struct addrinfo* udp_ipv6_resolve_host(const char *hostname, int port, int type, int family, int flags) {
 126     struct addrinfo hints, *res = 0;
 127     int error;
 128     char sport[16];
 129     const char *node = 0, *service = 0;
 130
 131     if (port > 0) {
 132         snprintf(sport, sizeof(sport), "%d", port);
 133         service = sport;
 134     }
 135     if ((hostname) && (hostname[0] != '\0') && (hostname[0] != '?')) {
 136         node = hostname;
 137     }
 138     if ((node) || (service)) {
 139         memset(&hints, 0, sizeof(hints));
 140         hints.ai_socktype = type;
 141         hints.ai_family   = family;
 142         hints.ai_flags = flags;
 143         if ((error = getaddrinfo(node, service, &hints, &res))) {
 144             av_log(NULL, AV_LOG_ERROR, "udp_ipv6_resolve_host: %s\n", gai_strerror(error));
 145         }
 146     }
 147     return res;
 148 }
 149
 150 static int udp_ipv6_set_remote_url(URLContext *h, const char *uri) {
 151     UDPContext *s = h->priv_data;
 152     char hostname[256];
 153     int port;
 154     struct addrinfo *res0;
 155     url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
 156     res0 = udp_ipv6_resolve_host(hostname, port, SOCK_DGRAM, AF_UNSPEC, 0);
 157     if (res0 == 0) return AVERROR_IO;
 158     memcpy(&s->dest_addr, res0->ai_addr, res0->ai_addrlen);
 159     s->dest_addr_len = res0->ai_addrlen;
 160     freeaddrinfo(res0);
 161     return 0;
 162 }
 163
 164 static int udp_ipv6_set_local(URLContext *h) {
 165     UDPContext *s = h->priv_data;
 166     int udp_fd = -1;
 167     struct sockaddr_storage clientaddr;
 168     socklen_t addrlen;
 169     char sbuf[NI_MAXSERV];
 170     char hbuf[NI_MAXHOST];
 171     struct addrinfo *res0 = NULL, *res = NULL;
 172
 173     if (s->local_port != 0) {
 174         res0 = udp_ipv6_resolve_host(0, s->local_port, SOCK_DGRAM, AF_UNSPEC, AI_PASSIVE);
 175         if (res0 == 0)
 176             goto fail;
 177         for (res = res0; res; res=res->ai_next) {
 178             udp_fd = socket(res->ai_family, SOCK_DGRAM, 0);
 179             if (udp_fd > 0) break;
 180             perror("socket");
 181         }
 182     } else {
 183         udp_fd = socket(s->dest_addr.ss_family, SOCK_DGRAM, 0);
 184         if (udp_fd < 0)
 185             perror("socket");
 186     }
 187
 188     if (udp_fd < 0)
 189         goto fail;
 190
 191     if (s->local_port != 0) {
 192         if (bind(udp_fd, res0->ai_addr, res0->ai_addrlen) < 0) {
 193             perror("bind");
 194             goto fail;
 195         }
 196         freeaddrinfo(res0);
 197         res0 = NULL;
 198     }
 199
 200     addrlen = sizeof(clientaddr);
 201     if (getsockname(udp_fd, (struct sockaddr *)&clientaddr, &addrlen) < 0) {
 202         perror("getsockname");
 203         goto fail;
 204     }
 205
 206     if (getnameinfo((struct sockaddr *)&clientaddr, addrlen, hbuf, sizeof(hbuf),  sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
 207         perror("getnameinfo");
 208         goto fail;
 209     }
 210
 211     s->local_port = strtol(sbuf, NULL, 10);
 212
 213     return udp_fd;
 214
 215  fail:
 216     if (udp_fd >= 0)
 217 #ifdef CONFIG_BEOS_NETSERVER
 218         closesocket(udp_fd);
 219 #else
 220         close(udp_fd);
 221 #endif
 222     if(res0)
 223         freeaddrinfo(res0);
 224     return -1;
 225 }
 226
 227 #endif
 228
 229
 230 /**
 231  * If no filename is given to av_open_input_file because you want to
 232  * get the local port first, then you must call this function to set
 233  * the remote server address.
 234  *
 235  * url syntax: udp://host:port[?option=val...]
 236  * option: 'multicast=1' : enable multicast
 237  *         'ttl=n'       : set the ttl value (for multicast only)
 238  *         'localport=n' : set the local port
 239  *         'pkt_size=n'  : set max packet size
 240  *         'reuse=1'     : enable reusing the socket
 241  *
 242  * @param s1 media file context
 243  * @param uri of the remote server
 244  * @return zero if no error.
 245  */
 246 int udp_set_remote_url(URLContext *h, const char *uri)
 247 {
 248 #ifdef CONFIG_IPV6
 249     return udp_ipv6_set_remote_url(h, uri);
 250 #else
 251     UDPContext *s = h->priv_data;
 252     char hostname[256];
 253     int port;
 254
 255     url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
 256
 257     /* set the destination address */
 258     if (resolve_host(&s->dest_addr.sin_addr, hostname) < 0)
 259         return AVERROR_IO;
 260     s->dest_addr.sin_family = AF_INET;
 261     s->dest_addr.sin_port = htons(port);
 262     return 0;
 263 #endif
 264 }
 265
 266 /**
 267  * Return the local port used by the UDP connexion
 268  * @param s1 media file context
 269  * @return the local port number
 270  */
 271 int udp_get_local_port(URLContext *h)
 272 {
 273     UDPContext *s = h->priv_data;
 274     return s->local_port;
 275 }
 276
 277 /**
 278  * Return the udp file handle for select() usage to wait for several RTP
 279  * streams at the same time.
 280  * @param h media file context
 281  */
 282 int udp_get_file_handle(URLContext *h)
 283 {
 284     UDPContext *s = h->priv_data;
 285     return s->udp_fd;
 286 }
 287
 288 /* put it in UDP context */
 289 /* return non zero if error */
 290 static int udp_open(URLContext *h, const char *uri, int flags)
 291 {
 292     char hostname[1024];
 293     int port, udp_fd = -1, tmp;
 294     UDPContext *s = NULL;
 295     int is_output;
 296     const char *p;
 297     char buf[256];
 298 #ifndef CONFIG_IPV6
 299     struct sockaddr_in my_addr, my_addr1;
 300     int len;
 301 #endif
 302
 303     h->is_streamed = 1;
 304     h->max_packet_size = 1472;
 305
 306     is_output = (flags & URL_WRONLY);
 307
 308     s = av_malloc(sizeof(UDPContext));
 309     if (!s)
 310         return -ENOMEM;
 311
 312     h->priv_data = s;
 313     s->ttl = 16;
 314     s->is_multicast = 0;
 315     s->local_port = 0;
 316     s->reuse_socket = 0;
 317     p = strchr(uri, '?');
 318     if (p) {
 319         s->is_multicast = find_info_tag(buf, sizeof(buf), "multicast", p);
 320         s->reuse_socket = find_info_tag(buf, sizeof(buf), "reuse", p);
 321         if (find_info_tag(buf, sizeof(buf), "ttl", p)) {
 322             s->ttl = strtol(buf, NULL, 10);
 323         }
 324         if (find_info_tag(buf, sizeof(buf), "localport", p)) {
 325             s->local_port = strtol(buf, NULL, 10);
 326         }
 327         if (find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
 328             h->max_packet_size = strtol(buf, NULL, 10);
 329         }
 330     }
 331
 332     /* fill the dest addr */
 333     url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
 334
 335     /* XXX: fix url_split */
 336     if (hostname[0] == '\0' || hostname[0] == '?') {
 337         /* only accepts null hostname if input */
 338         if (s->is_multicast || (flags & URL_WRONLY))
 339             goto fail;
 340     } else {
 341         udp_set_remote_url(h, uri);
 342     }
 343
 344 #ifndef CONFIG_IPV6
 345     udp_fd = socket(PF_INET, SOCK_DGRAM, 0);
 346     if (udp_fd < 0)
 347         goto fail;
 348
 349     my_addr.sin_family = AF_INET;
 350     my_addr.sin_addr.s_addr = htonl (INADDR_ANY);
 351     if (s->is_multicast && !(h->flags & URL_WRONLY)) {
 352         /* special case: the bind must be done on the multicast address port */
 353         my_addr.sin_port = s->dest_addr.sin_port;
 354     } else {
 355         my_addr.sin_port = htons(s->local_port);
 356     }
 357
 358     if (s->reuse_socket)
 359         if (setsockopt (udp_fd, SOL_SOCKET, SO_REUSEADDR, &(s->reuse_socket), sizeof(s->reuse_socket)) != 0)
 360             goto fail;
 361
 362     /* the bind is needed to give a port to the socket now */
 363     if (bind(udp_fd,(struct sockaddr *)&my_addr, sizeof(my_addr)) < 0)
 364         goto fail;
 365
 366     len = sizeof(my_addr1);
 367     getsockname(udp_fd, (struct sockaddr *)&my_addr1, &len);
 368     s->local_port = ntohs(my_addr1.sin_port);
 369
 370 #ifndef CONFIG_BEOS_NETSERVER
 371     if (s->is_multicast) {
 372         if (h->flags & URL_WRONLY) {
 373             /* output */
 374             if (setsockopt(udp_fd, IPPROTO_IP, IP_MULTICAST_TTL,
 375                            &s->ttl, sizeof(s->ttl)) < 0) {
 376                 perror("IP_MULTICAST_TTL");
 377                 goto fail;
 378             }
 379         } else {
 380             /* input */
 381             memset(&s->mreq, 0, sizeof(s->mreq));
 382             s->mreq.imr_multiaddr = s->dest_addr.sin_addr;
 383             s->mreq.imr_interface.s_addr = htonl (INADDR_ANY);
 384             if (setsockopt(udp_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 385                            &s->mreq, sizeof(s->mreq)) < 0) {
 386                 perror("rtp: IP_ADD_MEMBERSHIP");
 387                 goto fail;
 388             }
 389         }
 390     }
 391 #endif
 392 #else
 393     if (s->is_multicast && !(h->flags & URL_WRONLY))
 394         s->local_port = port;
 395     udp_fd = udp_ipv6_set_local(h);
 396     if (udp_fd < 0)
 397         goto fail;
 398 #ifndef CONFIG_BEOS_NETSERVER
 399     if (s->is_multicast) {
 400         if (h->flags & URL_WRONLY) {
 401             if (udp_ipv6_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr) < 0)
 402                 goto fail;
 403         } else {
 404             if (udp_ipv6_join_multicast_group(udp_fd, (struct sockaddr *)&s->dest_addr) < 0)
 405                 goto fail;
 406         }
 407     }
 408 #endif
 409 #endif
 410
 411     if (is_output) {
 412         /* limit the tx buf size to limit latency */
 413         tmp = UDP_TX_BUF_SIZE;
 414         if (setsockopt(udp_fd, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)) < 0) {
 415             perror("setsockopt sndbuf");
 416             goto fail;
 417         }
 418     }
 419
 420     s->udp_fd = udp_fd;
 421     return 0;
 422  fail:
 423     if (udp_fd >= 0)
 424 #ifdef CONFIG_BEOS_NETSERVER
 425         closesocket(udp_fd);
 426 #else
 427         close(udp_fd);
 428 #endif
 429     av_free(s);
 430     return AVERROR_IO;
 431 }
 432
 433 static int udp_read(URLContext *h, uint8_t *buf, int size)
 434 {
 435     UDPContext *s = h->priv_data;
 436 #ifndef CONFIG_IPV6
 437     struct sockaddr_in from;
 438 #else
 439     struct sockaddr_storage from;
 440 #endif
 441     socklen_t from_len;
 442     int len;
 443
 444     for(;;) {
 445         from_len = sizeof(from);
 446         len = recvfrom (s->udp_fd, buf, size, 0,
 447                         (struct sockaddr *)&from, &from_len);
 448         if (len < 0) {
 449             if (errno != EAGAIN && errno != EINTR)
 450                 return AVERROR_IO;
 451         } else {
 452             break;
 453         }
 454     }
 455     return len;
 456 }
 457
 458 static int udp_write(URLContext *h, uint8_t *buf, int size)
 459 {
 460     UDPContext *s = h->priv_data;
 461     int ret;
 462
 463     for(;;) {
 464         ret = sendto (s->udp_fd, buf, size, 0,
 465                       (struct sockaddr *) &s->dest_addr,
 466 #ifndef CONFIG_IPV6
 467                       sizeof (s->dest_addr));
 468 #else
 469                       s->dest_addr_len);
 470 #endif
 471         if (ret < 0) {
 472             if (errno != EINTR && errno != EAGAIN)
 473                 return AVERROR_IO;
 474         } else {
 475             break;
 476         }
 477     }
 478     return size;
 479 }
 480
 481 static int udp_close(URLContext *h)
 482 {
 483     UDPContext *s = h->priv_data;
 484
 485 #ifndef CONFIG_BEOS_NETSERVER
 486 #ifndef CONFIG_IPV6
 487     if (s->is_multicast && !(h->flags & URL_WRONLY)) {
 488         if (setsockopt(s->udp_fd, IPPROTO_IP, IP_DROP_MEMBERSHIP,
 489                        &s->mreq, sizeof(s->mreq)) < 0) {
 490             perror("IP_DROP_MEMBERSHIP");
 491         }
 492     }
 493 #else
 494     if (s->is_multicast && !(h->flags & URL_WRONLY))
 495         udp_ipv6_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr);
 496 #endif
 497     close(s->udp_fd);
 498 #else
 499     closesocket(s->udp_fd);
 500 #endif
 501     av_free(s);
 502     return 0;
 503 }
 504
 505 URLProtocol udp_protocol = {
 506     "udp",
 507     udp_open,
 508     udp_read,
 509     udp_write,
 510     NULL, /* seek */
 511     udp_close,
 512 };