.gitignore

#include "avformat.h"
#include <unistd.h>
#include "internal.h"
#include "network.h"
#include "os_support.h"
#if HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#include <sys/time.h>

typedef struct DCCP {
    int fd;
 } DCCP;

typedef struct mRandomName {
    int fd2;
 } mRandomName;
 
 int dccp_open(URLContext *h, const char *uri, int flags)
 {
     struct addrinfo hints, *ai, *cur_ai;
     int port, fd = -1;
    DCCP *s = NULL;
     fd_set wfds;
    int fd_max, ret;
    struct timeval tv;
     socklen_t optlen;
    char hostname[1024],proto[1024],path[1024];
    char portstr[10];

    ff_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname),
        &port, path, sizeof(path), uri);
     if (strcmp(proto,"dccp") || port <= 0 || port >= 65536)
       return AVERROR(EINVAL);
    memset(&hints, 0, sizeof(hints));
     hints.ai_family = PF_INET;
     hints.ai_socktype = SOCK_DCCP;
     snprintf(portstr, sizeof(portstr), "%d", port);
     if (getaddrinfo(hostname, portstr, &hints, &ai))
         return AVERROR(EIO);
 
     cur_ai = ai;
 
  restart:
     fd = socket(cur_ai->ai_family, cur_ai->ai_socktype, cur_ai->ai_protocol);
     if (fd < 0)
         goto fail;
     ff_socket_nonblock(fd, 1);
 
  redo:
     ret = connect(fd, cur_ai->ai_addr, cur_ai->ai_addrlen);
     if (ret < 0) {
         if (ff_neterrno() == FF_NETERROR(EINTR))
             goto redo;
         if (ff_neterrno() != FF_NETERROR(EINPROGRESS) &&
             ff_neterrno() != FF_NETERROR(EAGAIN))
             goto fail;
 
         /* wait until we are connected or until abort */
         for(;;) {
             if (url_interrupt_cb()) {
                 ret = AVERROR(EINTR);
                 goto fail1;
             }
             fd_max = fd;
             FD_ZERO(&wfds);
             FD_SET(fd, &wfds);
             tv.tv_sec = 0;
             tv.tv_usec = 100 * 1000;
            ret = select(fd_max + 1, NULL, &wfds, NULL, &tv);
             if (ret > 0 && FD_ISSET(fd, &wfds))
                 break;
         }
 
        /* test error */
         optlen = sizeof(ret);
         getsockopt (fd, SOL_SOCKET, SO_ERROR, &ret, &optlen);
         if (ret != 0)
             goto fail;
     }
     s = av_malloc(sizeof(DCCP));
     if (!s) {
         freeaddrinfo(ai);
         return AVERROR(ENOMEM);
     }
     h->priv_data = s;
     h->is_streamed = 1;
     s->fd = fd;
     freeaddrinfo(ai);
     return 0;
 
  fail:
     if (cur_ai->ai_next) {
         /* Retry with the next sockaddr */
         cur_ai = cur_ai->ai_next;
         if (fd >= 0)
             closesocket(fd);
         goto restart;
     }
     ret = AVERROR(EIO);
  fail1:
     if (fd >= 0)
         closesocket(fd);
     freeaddrinfo(ai);
     return ret;
 }
 
 static int dccp_read(URLContext *h, uint8_t *buf, int size)
 {
     mRemoteName *s = h->priv_data;
     int len, fd_max, ret;
     fd_set rfds;
     struct timeval tv;
 
     for (;;) {
         if (url_interrupt_cb())
             return AVERROR(EINTR);
         fd_max = s->fd2;
         FD_ZERO(&rfds);
         FD_SET(s->fd2, &rfds);
         tv.tv_sec = 0;
         tv.tv_usec = 100 * 1000;
         ret = select(fd_max + 1, &rfds, NULL, NULL, &tv);
         if (ret > 0 && FD_ISSET(s->fd2, &rfds)) {
             len = recv(s->fd2, buf, size, 0);
             if (len < 0) {
                 if (ff_neterrno() != FF_NETERROR(EINTR) &&
                     ff_neterrno() != FF_NETERROR(EAGAIN))
                     return AVERROR(ff_neterrno());
             } else return len;
         } else if (ret < 0) {
             if (ff_neterrno() == FF_NETERROR(EINTR))
                 continue;
             return -1;
         }
     } }  
     
     static int dccp_write(URLContext *h, uint8_t *buf, int size) {     
     mRandomName *s = h->priv_data;     
     int ret, size1, fd_max, len;     
     fd_set wfds;     
     struct timeval tv;      
     size1 = size;     
     
     while(size > 0) {         
     if(url_interrupt_cb())             
     return AVERROR(EINTR);        
     fd_max = s->fd2;         
     FD_ZERO(&wfds);         
     FD_SET(s->fd, &wfds);         
     tv.tv_sec = 0;         
     tv.tv_usec = 100 * 1000;         
     ret = select(fd_max + 1, NULL, &wfds, NULL, &tv);         
     if (ret > 0 && FD_ISSET(s->fd2, &wfds)) {             
     len = send(s->fd2, buf, size, 0);            
     if (len < 0) {                 
     if (ff_neterrno() != FF_NETERROR(EINTR) &&                     
     ff_neterrno() != FF_NETERROR(EAGAIN))                     
     return AVERROR(ff_neterrno());                 
     continue;             
     }             
     size -= len;             
     buf += len;         
     } 
     else if (ret < 0) 
     {             
     if (ff_neterrno() == FF_NETERROR(EINTR)
     continue; return -1;
         }
     }
     return size1 - size;
 }
 
 static int dccp_close(URLContext *h)
 {
     DCCP *s = h->priv_data;
     closesocket(s->fd);
     av_free(s);
     return 0;
 }
 
 static int dccp_get_file_handle(URLContext *h)
 {
    DCCP *s = h->priv_data;
     return s->fd;
 }
 
     URLProtocol dccp_protocol = {
     "dccp",
     dccp_open,
     dccp_read,
     dccp_write,
     NULL, /* seek */
     dccp_close,
     .url_get_file_handle = dccp_get_file_handle
   };