我的 uvlib 默认循环意外退出 - 为什么？

Question

我正在开发一个程序来监视 UDP 端口的“发现”数据包。当它收到数据包时，它将数据包回显给发送者，然后应该等待发送者的进一步命令。

这是使用 uvlib 实现的（基于 uvlib 文档，此处示例：http://docs.libuv.org/en/v1.x/guide/networking.html#udp）。我初始化了一个接收套接字（以等待发现数据包）和一个广播套接字（用于回复发现）。当 UDP 数据进来时，触发 on_UDP_read 回调。在这个回调中，我得到了调用者的 IP 和端口，并发送了 echo 数据包。

这一切都很好（发送系统收到回显的数据包）；问题是主循环（uv_run（loop，UV_RUN_DEFAULT）应该在回复后继续运行......但是，它以零返回码退出。我不能简单地在（kludge）循环中再次启动它，因为发送系统每次都会选择一个新端口（标准UDP行为），所以我不能（以后）发送我想发送的批量数据。

问题：为什么主循环会停止，就像我发出了 uv_stop 命令一样？

我想知道我的内存使用是否有问题。发送缓冲区在函数中分配，如下所示： const uv_buf_t a[] 。 （也许这必须使用 malloc 完成？？）

这是程序：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <uv.h>
#include <string.h>
#include<arpa/inet.h>
#include <pthread.h>
#include <semaphore.h>
#include <math.h>
#include <sys/socket.h>
#include <unistd.h>
#include <time.h>
#include "de_signals.h"

#define BUFFERLEN 65    // Maximum length of buffer
#define PORT 1024   // Port to watch

uv_loop_t *loop;
uv_udp_t send_socket;
uv_udp_t recv_socket;

//sem_t mutex;
//pthread_t t1;

int sockfd;  // socket definition for UDP
struct sockaddr_in servaddr; 

static void alloc_buffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
  buf->base = malloc(suggested_size);
  buf->len = suggested_size;
}

//struct sockaddr_in si_DE, si_main;

void on_UDP_send(uv_udp_send_t* req, int status)
{
  printf("UDP send complete, status = %d\n", status);
  // the following is supposed to free the send buffer, but causes a segmentation fault
  //free(req);
  return;
}

void on_UDP_read(uv_udp_t *req, ssize_t nread, const uv_buf_t *buf, const struct sockaddr *addr, unsigned flags) {
    puts("UDP data detected");
    if (nread < 0) {
        fprintf(stderr, "Read error %s\n", uv_err_name(nread));
        uv_close((uv_handle_t*) req, NULL);
        free(buf->base);
        return;
    }

    char sender[17] = { 0 };
    uv_ip4_name((const struct sockaddr_in*) addr, sender, 16);
    fprintf(stderr, "Recv from %s\n", sender);

    struct sockaddr_in *sin = (struct sockaddr_in *) addr;
    char ip[INET_ADDRSTRLEN];
    uint16_t port;
    port = htons (sin->sin_port);
    printf("port = %d \n",port);

    int sentBytes;
    char replybuf[60];

    uv_ip4_name((const struct sockaddr_in*) addr, sender, 16);
    fprintf(stderr, "Recv from %s\n", sender);
    for(int i=0;i<nread;i++){fprintf(stderr,"%02X ",buf->base[i]);}
    fprintf(stderr,"\n");

    puts("create discovery reply buf");
    char b[60];
    for(int i=0;i<60;i++) {b[i] = 0;}
    if((buf->base[0] & 0xFF) == 0xEF && (buf->base[1] & 0xFF) == 0xFE) {
    fprintf(stderr,"discovery packet detected\n");
    b[0] = 0xEF;
    b[1] = 0xFE;
    b[2] = 0x02;
    }
    if((buf->base[0] & 0xFF) == 0x53 && (buf->base[1] & 0xFF) == 0x3F) {
    fprintf(stderr, "STATUS INQUIRY detected\n");
    b[0] = 0x4F;
        b[1] = 0x4B;
    port = 1024; // temporary, until we have a better way
    sleep(1); // let LH get socket open
    }


////////////// reply ///////////////

    uv_udp_send_t send_req;

    puts("create discovery reply buf");

    const uv_buf_t a[]={{.base = b, .len=60}};

    for(int i=0;i<60;i++){fprintf(stderr,"%02X ",a[0].base[i]);}; 
    fprintf(stderr,"\n");

    puts("ready to send");


// Here we reply to sender, using sender's IP and port

    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port);
    struct hostent* hptr = gethostbyname(sender);
    if(!hptr) puts ("gethostbyname error");
    servaddr.sin_addr.s_addr =     //INADDR_ANY; 
    ((struct in_addr*) hptr->h_addr_list[0])->s_addr;

    uv_udp_send(&send_req, &send_socket, a, 1, (const struct sockaddr *)&servaddr,
     on_UDP_send);


   puts("reply issued");

   // free(buf->base);
    uv_udp_recv_stop(req);   // ???
    puts("returning from processing UDP packet");
    return;
}

/////////////////////////////////////////////////////////////////////////////////
int main() {
 int retcode;
 //while(1==1)  // this is a kludgy extra loop until we find out why uv_run halts.
 //{



  puts("starting");
    loop = uv_default_loop();

    uv_udp_init(loop, &recv_socket);
    struct sockaddr_in recv_addr;
    uv_ip4_addr("0.0.0.0", 1024, &recv_addr);
    uv_udp_bind(&recv_socket, (const struct sockaddr *)&recv_addr, UV_UDP_REUSEADDR);
    uv_udp_recv_start(&recv_socket, alloc_buffer, on_UDP_read);

    uv_udp_init(loop, &send_socket);
    struct sockaddr_in broadcast_addr;
    uv_ip4_addr("0.0.0.0", 0, &broadcast_addr);
    uv_udp_bind(&send_socket, (const struct sockaddr *)&broadcast_addr, 0);
    uv_udp_set_broadcast(&send_socket, 1); puts("wait for UDP handshake\n");

  // Creating socket file descriptor for UDP
  if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) { 
        perror("socket creation failed"); 
        exit(EXIT_FAILURE); 
      }


  puts("start main loop");
  retcode = uv_run(loop, UV_RUN_DEFAULT);

  fprintf(stderr,"Return code from uv_run loop = %d \n",retcode);
 //}
 puts("out of main loop");
  return retcode;
}

Answer 1

我想出了其中的一部分。首先，“uvlib”不是包名； “libuv”是。其次，循环退出的原因是因为在on_read回调例程的末尾有一个uv_udp_recv_stop(req)指令。当没有更多工作要做时，libuv 会退出。

仍然存在的问题：如果您删除 uv_udp_recv_stop(req) 指令，认为这可能会使循环继续运行（应该如此），程序会因分段错误而崩溃。我向 libuv 团队报告了这一点（使用 Github 问题报告），但他们没有提供帮助，因为他们对发布在 github 的 libuv 存储库中的示例程序的正确性不承担任何责任。有趣的是，当您安装 libuv 并运行检查（即运行他们的测试）时，与 UDP 多播相关的测试都失败了。这表明 libuv 包在 UDP 区域确实存在一些错误；我报告了这个，但我猜 libuv 团队有更大的鱼要炒。