Sockets 套接字sendto（）失败错误号88和9

我正在尝试使用UDP运行一个简单的客户机-服务器应用程序（作为练习），OSLinuxMint14。 客户端在启动时向服务器发送请求，以获取一些会话参数，包括usec中的超时。 客户端打开一个套接字并设置一个默认的超时值，以便在recvfrom上不间断地阻止non，然后发送对这些参数的请求，关闭所述套接字，重新打开一个设置新超时值的套接字，最后向用户请求命令

parameters请求由一个子函数处理，该子函数获取指向客户机套接字的指针，这样，如果新的sockfd是不同的数字，则主函数也可以引用新的套接字。 （返回值用作校验值，零或非零）

顺序是：

• 客户端调用传递套接字指针的子函数
• 子函数发送请求
• 子函数得到答案
• 子函数关闭旧套接字
• 子函数在套接字指针指向的位置打开新套接字（socket（）、setsockopt、bind（））（从而替换原始套接字）
  -问题
• 对sendto（）的下一次调用失败，错误为errno 9（错误文件号）或errno 88（非套接字上的套接字操作）

对main中函数的调用：（servaddr是结构sockaddr_in，因此cast；sockfd是int）

clientrequest（）说明：

 int clientparameters(int* socketpt, struct sockaddr* remaddr, unsigned int parameters[])

{
unsigned char timeouts = 0;
int received = 0;
socklen_t len;
unsigned char* buff;
if((buff = malloc(MAX_LINE)) == NULL) {
    fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    return -1;
}
unsigned char i;







    memset(buff, 0, MAX_LINE);
    if(encode(buff, PARAM) < 0) {
        fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
        free(buff);
        return -1;
    }



    if(sendto(*socketpt, buff, 1, 0, remaddr, sizeof(struct sockaddr)) < 0) {
        fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
        free(buff);
        return -1;
    }

    while(received == 0) {


        len = sizeof(struct sockaddr);
        if((received = recvfrom(*socketpt, buff, MAX_LINE, 0, remaddr, &len)) < 0) {

            if(errno == EWOULDBLOCK) {
                if(timeouts == TIMEOUT_NUM) {
                    fprintf(stderr, "Server non found, process %d, errno %d\n", getpid(), errno);
                    free(buff);
                    return -1;
                }
                received = 0;
                timeouts++;


            }
            else {
                fprintf(stderr, "Error occurred, process %d\n errno: %d\n", getpid(), errno);
                free(buff);
                return -1;
            }
        }
    }
}


memcpy(parameters, uncap(buff), sizeof(unsigned int)*3);
/*"uncap" removes user-level protocol header from payload*/

free(buff);



/*Store old socket port + IP address*/
struct sockaddr_in addr;
len = sizeof(struct sockaddr);
if(getsockname(*socketpt, (struct sockaddr*)&addr, &len) < 0) {
    fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    return -1;
}



if(close(*socketpt) < 0) {
    fprintf(stderr,"Errore occurred, process %d, errno %d\n", getpid(), errno);
    return -1;
}

/*Opens new socket*/
if(((*socketpt) = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    return -1;
}


/*Set timer*/
struct timeval t;
t.tv_usec = parameters[2]; //Where timer is set

if(setsockopt(*socketpt, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0 ) {
    fprintf(stderr, "errno: %d\n win: %u\t loss: %u\t timeout: %u\n\n", errno, parameters[0], parameters[1], parameters[2]);
    fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    if(close(*socketpt) < 0) {
        fprintf(stderr, "Errore in close() in clientrequest(), processo %d, errno %d\n", getpid(), errno);
    }
    return(-1);
}

if(bind(*socketpt, (struct sockaddr*)&addr, sizeof(struct sockaddr)) < 0) {
    fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    if(close(*socketpt) < 0) {
        fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    }
    return(-1);
}

return 0;

int-clientparameters（int*socketpt、struct-sockaddr*remaddr、unsigned-int-parameters[]
{
无符号字符超时=0；
接收到的int=0；
索克伦；
未签名字符*buff；
如果（（buff=malloc（MAX_线））==NULL）{
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
返回-1；
}
无符号字符i；
memset（buff，0，最大线）；
if（编码（buff，PARAM）<0）{
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
免费（buff）；
返回-1；
}
如果（发送到（*socketpt，buff，1，0，remaddr，sizeof（struct sockaddr））<0）{
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
免费（buff）；
返回-1；
}
while（接收==0）{
len=sizeof（结构sockaddr）；
如果（（已接收=recvfrom（*socketpt，buff，MAX_LINE，0，remaddr，&len））<0）{
if（errno==ewoldblock）{
如果（超时==超时值）{
fprintf（stderr，“找不到服务器，进程%d，错误号%d\n”，getpid（），错误号）；
免费（buff）；
返回-1；
}
接收=0；
超时++；
}
否则{
fprintf（stderr，“发生错误，进程%d\n错误号：%d\n”，getpid（），错误号）；
免费（buff）；
返回-1；
}
}
}
}
memcpy（参数、uncap（buff）、sizeof（unsigned int）*3）；
/*“uncap”从有效负载中删除用户级协议头*/
免费（buff）；
/*存储旧套接字端口+IP地址*/
地址中的结构sockaddr\u；
len=sizeof（结构sockaddr）；
if（getsockname（*socketpt，（struct sockaddr*）&addr，&len）<0）{
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
返回-1；
}
如果（关闭（*socketpt）<0）{
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
返回-1；
}
/*打开新的套接字*/
如果（（*socketpt）=套接字（AF_INET，SOCK_DGRAM，0））<0{
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
返回-1；
}
/*设定计时器*/
结构时间值t；
t、 tv_usec=参数[2]//设置计时器的位置
if（setsockopt（*socketpt，SOL_SOCKET，SO_RCVTIMEO，&t，sizeof（struct timeval））<0）{
fprintf（标准，“错误号：%d\n赢：%u\t输：%u\t超时：%u\n\n”，错误号，参数[0]，参数[1]，参数[2]）；
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
如果（关闭（*socketpt）<0）{
fprintf（stderr，“clientrequest（）中关闭时出错（），进程%d，错误号%d\n”，getpid（），错误号）；
}
返回（-1）；
}
if（bind（*socketpt，（struct sockaddr*）&addr，sizeof（struct sockaddr））<0{
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
如果（关闭（*socketpt）<0）{
fprintf（stderr，“发生错误，进程%d，错误号%d\n”，getpid（），错误号）；
}
返回（-1）；
}
返回0；

}

当我输入第二个请求函数时，它在第一个sendto（）时失败，错误号为88

这是我试过的一些沙盒代码。它基本上遵循相同的socket（）、setsockopt（）、bind（）、sendto（）、close（）方法，除了“sendto”将套接字绑定发送到相同的IP/端口

int* receptionfd = malloc(4);

struct sockaddr_in addr;
char buff[MAX_LINE];

int n;
unsigned int len;


if((*receptionfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    perror("Error occurred\n");
    free(receptionfd);
    exit(-1);
}

memset((void*)&addr, 0, sizeof(addr));


addr.sin_family = AF_INET;

if(inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) <= 0) {
    perror("Errore occurred\n");
    free(receptionfd);
    exit(-1);
}

addr.sin_port = htons(5050);


struct timeval t;
t.tv_usec = 20000;

if(setsockopt(*receptionfd, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0 ) {
    fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    if(close(*receptionfd) < 0) {
        fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    }
    return(-1);
}



if(bind(*receptionfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
    perror("Error occurred\n");
    free(receptionfd);
    exit(-1);
}


if(sendto(*receptionfd, buff, 0, 0, (struct sockaddr*)&addr, sizeof(struct sockaddr)) < 0) {
    fprintf(stderr, "Error occurred, first sendto(), errno %d\n", errno);
    free(receptionfd);
    exit(-1);
}
else
    printf("First good\n");

close(*receptionfd);

createsock(receptionfd, addr);

if(sendto(*receptionfd, buff, 0, 0, (struct sockaddr*)&addr, sizeof(struct sockaddr)) < 0) {
    fprintf(stderr, "Error occurred, second sendto(), errno %d\n", errno);
    free(receptionfd);
    exit(-1);
}
else {
    printf("Second good\n");
}

close(*receptionfd);
free(receptionfd);
exit(0);

int*receptionfd=malloc（4）；
地址中的结构sockaddr\u；
字符buff[最大行]；
int n；
无符号整数len；
如果（*receptionfd=socket（AF_INET，SOCK_DGRAM，0））<0）{
perror（“发生错误\n”）；
免费（接收FD）；
出口（-1）；
}
memset（（void*）和addr，0，sizeof（addr））；
addr.sin_family=AF_INET；
if（inet\u pton（AF\u inet，“127.0.0.1”和addr.sin\u addr）请原谅，但是你展示的源代码不仅很多，而且在格式上也很混乱。可能不仅仅是我拒绝阅读它们。第一-代码格式非常糟糕。请清理它。到-这里有太多的代码。请将其减少到演示/再现问题所需的最低限度。第三-
clientparameters（）
您展示的函数具有不匹配的大括号，所以它甚至无法编译，更不用说运行了。我不再关注它了。
int* receptionfd = malloc(4);

struct sockaddr_in addr;
char buff[MAX_LINE];

int n;
unsigned int len;


if((*receptionfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    perror("Error occurred\n");
    free(receptionfd);
    exit(-1);
}

memset((void*)&addr, 0, sizeof(addr));


addr.sin_family = AF_INET;

if(inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) <= 0) {
    perror("Errore occurred\n");
    free(receptionfd);
    exit(-1);
}

addr.sin_port = htons(5050);


struct timeval t;
t.tv_usec = 20000;

if(setsockopt(*receptionfd, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0 ) {
    fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    if(close(*receptionfd) < 0) {
        fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
    }
    return(-1);
}



if(bind(*receptionfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
    perror("Error occurred\n");
    free(receptionfd);
    exit(-1);
}


if(sendto(*receptionfd, buff, 0, 0, (struct sockaddr*)&addr, sizeof(struct sockaddr)) < 0) {
    fprintf(stderr, "Error occurred, first sendto(), errno %d\n", errno);
    free(receptionfd);
    exit(-1);
}
else
    printf("First good\n");

close(*receptionfd);

createsock(receptionfd, addr);

if(sendto(*receptionfd, buff, 0, 0, (struct sockaddr*)&addr, sizeof(struct sockaddr)) < 0) {
    fprintf(stderr, "Error occurred, second sendto(), errno %d\n", errno);
    free(receptionfd);
    exit(-1);
}
else {
    printf("Second good\n");
}

close(*receptionfd);
free(receptionfd);
exit(0);

void createsock(int* receptionfd, struct sockaddr_in addr) {
if(((*receptionfd) = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
            perror("Error occurred\n");
            free(receptionfd);
            exit(-1);
    }

    memset((void*)&addr, 0, sizeof(addr));


    addr.sin_family = AF_INET;

    if(inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) <= 0) {
        perror("Error occurred\n");
        free(receptionfd);
        exit(-1);
    }

    addr.sin_port = htons(5050);



    struct timeval t;
    t.tv_usec = 20000;

    if(setsockopt(*receptionfd, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0 ) {
        fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
        if(close(*receptionfd) < 0) {
            fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
        }
    }


    if(bind(*receptionfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        perror("Error occurred\n");
        exit(-1);
    }