avformat/udp: make recv addr of each packet available

Timo Rothenpieler committed 1 year ago

Commit af04a271 parent 2c7e1172 files · +36 −18Browse files

Unified · Split

2 files

libavformat/network.h +2 −0
libavformat/udp.c +34 −18

@@ -338,4 +338,6 @@ int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address, · 337 unmodified lines
338	int parallel, URLContext h, int fd,	338	int parallel, URLContext h, int fd,
339	int (customize_fd)(void , int, int), void *customize_ctx);	339	int (customize_fd)(void , int, int), void *customize_ctx);
340		340
		341	void ff_udp_get_last_recv_addr(URLContext h, struct sockaddr_storage addr, socklen_t *addr_len);
		342
341	#endif /* AVFORMAT_NETWORK_H */	343	#endif /* AVFORMAT_NETWORK_H */

libavformat/udp.c+34−18

 #define UDP_MAX_PKT_SIZE 65536
 #define UDP_HEADER_SIZE 8
+typedef struct UDPQueuedPacketHeader {
+    int pkt_size;
+    struct sockaddr_storage addr;
+    socklen_t addr_len;
+} UDPQueuedPacketHeader;
 typedef struct UDPContext {
     const AVClass *class;
     int udp_fd;
     pthread_cond_t cond;
     int thread_started;
 #endif
-    uint8_t tmp[UDP_MAX_PKT_SIZE+4];
+    uint8_t tmp[UDP_MAX_PKT_SIZE + sizeof(UDPQueuedPacketHeader)];
     int remaining_in_dg;
     char *localaddr;
     int timeout;
     char *sources;
     char *block;
     IPSourceFilters filters;
+    struct sockaddr_storage last_recv_addr;
+    socklen_t last_recv_addr_len;
 } UDPContext;
 #define OFFSET(x) offsetof(UDPContext, x)
     return s->local_port;
 }
+void ff_udp_get_last_recv_addr(URLContext *h, struct sockaddr_storage *addr, socklen_t *addr_len)
+{
+    UDPContext *s = h->priv_data;
+    *addr = s->last_recv_addr;
+    *addr_len = s->last_recv_addr_len;
+}
 /**
  * Return the udp file handle for select() usage to wait for several RTP
  * streams at the same time.
         goto end;
     }
     while(1) {
-        int len;
+        UDPQueuedPacketHeader pkt_header;
-        struct sockaddr_storage addr;
-        socklen_t addr_len = sizeof(addr);
         pthread_mutex_unlock(&s->mutex);
         /* Blocking operations are always cancellation points;
            see "General Information" / "Thread Cancelation Overview"
            in Single Unix. */
         pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old_cancelstate);
-        len = recvfrom(s->udp_fd, s->tmp+4, sizeof(s->tmp)-4, 0, (struct sockaddr *)&addr, &addr_len);
+        pkt_header.pkt_size = recvfrom(s->udp_fd, s->tmp + sizeof(pkt_header), sizeof(s->tmp) - sizeof(pkt_header), 0, (struct sockaddr *)&pkt_header.addr, &pkt_header.addr_len);
         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate);
         pthread_mutex_lock(&s->mutex);
-        if (len < 0) {
+        if (pkt_header.pkt_size < 0) {
             if (ff_neterrno() != AVERROR(EAGAIN) && ff_neterrno() != AVERROR(EINTR)) {
                 s->circular_buffer_error = ff_neterrno();
                 goto end;
             }
             continue;
         }
-        if (ff_ip_check_source_lists(&addr, &s->filters))
+        if (ff_ip_check_source_lists(&pkt_header.addr, &s->filters))
             continue;
-        AV_WL32(s->tmp, len);
+        memcpy(s->tmp, &pkt_header, sizeof(pkt_header));
-        if (av_fifo_can_write(s->fifo) < len + 4) {
+        if (av_fifo_can_write(s->fifo) < pkt_header.pkt_size + sizeof(pkt_header)) {
             /* No Space left */
             if (s->overrun_nonfatal) {
                 av_log(h, AV_LOG_WARNING, "Circular buffer overrun. "
                 goto end;
             }
         }
-        av_fifo_write(s->fifo, s->tmp, len + 4);
+        av_fifo_write(s->fifo, s->tmp, pkt_header.pkt_size + sizeof(pkt_header));
         pthread_cond_signal(&s->cond);
     }
 {
     UDPContext *s = h->priv_data;
     int ret;
-    struct sockaddr_storage addr;
-    socklen_t addr_len = sizeof(addr);
 #if HAVE_PTHREAD_CANCEL
     int avail, nonblock = h->flags & AVIO_FLAG_NONBLOCK;
         do {
             avail = av_fifo_can_read(s->fifo);
             if (avail) { // >=size) {
-                uint8_t tmp[4];
+                UDPQueuedPacketHeader header;
+                av_fifo_read(s->fifo, &header, sizeof(header));
+                s->last_recv_addr = header.addr;
+                s->last_recv_addr_len = header.addr_len;
-                av_fifo_read(s->fifo, tmp, 4);
+                avail = header.pkt_size;
-                avail = AV_RL32(tmp);
                 if(avail > size){
                     av_log(h, AV_LOG_WARNING, "Part of datagram lost due to insufficient buffer size\n");
                     avail = size;
                 }
                 av_fifo_read(s->fifo, buf, avail);
-                av_fifo_drain2(s->fifo, AV_RL32(tmp) - avail);
+                av_fifo_drain2(s->fifo, header.pkt_size - avail);
                 pthread_mutex_unlock(&s->mutex);
                 return avail;
             } else if(s->circular_buffer_error){
         if (ret < 0)
             return ret;
     }
-    ret = recvfrom(s->udp_fd, buf, size, 0, (struct sockaddr *)&addr, &addr_len);
+    s->last_recv_addr_len = sizeof(s->last_recv_addr);
+    ret = recvfrom(s->udp_fd, buf, size, 0, (struct sockaddr *)&s->last_recv_addr, &s->last_recv_addr_len);
     if (ret < 0)
         return ff_neterrno();
-    if (ff_ip_check_source_lists(&addr, &s->filters))
+    if (ff_ip_check_source_lists(&s->last_recv_addr, &s->filters))
         return AVERROR(EINTR);
     return ret;
 }

avformat/udp: make recv addr of each packet available

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code