logo标签列表

套接字编程：'accept：坏的文件描述符'

c++csocketsnetwork-programming
3
我正在尝试编写一个游戏，可以让多个客户端连接和玩 - 下面是相关的代码（非常混乱 - 以后会整理）： < p > < em >编辑：我意识到这需要很多滚动...崩溃发生在游戏结束时：

    std::cout << black_hits << " black hits & " << white_hits
                << " white hits.\n";

    if (black_hits == 4) {
        std::cout << "you won!\n";
        std::cin.ignore().get();
        close(client); //<<<< CRASH HERE
        return 0;
    }

其实并不是真正的崩溃...但已经很接近了 :)

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <string>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>

#define BACKLOG 10
#define MAXDATASIZE 100

typedef enum {RED,GREEN,BLUE,YELLOW,ORANGE} color;
int StartMasterMind(int client, sockaddr_storage addr_in); 

struct msgstruct {
        int length;
        char* send_data;
};

void sigchld_handler(int s)
{
    while(waitpid(-1, NULL, WNOHANG) > 0);
}

// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
    if (sa->sa_family == AF_INET) {
        return &(((struct sockaddr_in*)sa)->sin_addr);
    }

    return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

int tcp_connect(const char *serv, const char *host = NULL)
{
    int sockfd, new_fd;  // listen on sock_fd, new connection on new_fd
    struct addrinfo hints, *servinfo, *p;
    struct sockaddr_storage their_addr; // connector's address information
    socklen_t sin_size;
    struct sigaction sa;
    int yes=1;
    char s[INET6_ADDRSTRLEN];
    int rv;

    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE; // use my IP

    if ((rv = getaddrinfo(host, serv, &hints, &servinfo)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        return 1;
    }

    // loop through all the results and bind to the first we can
    for(p = servinfo; p != NULL; p = p->ai_next) {
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
                p->ai_protocol)) == -1) {
            perror("server: socket");
            continue;
        }

        if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
                sizeof(int)) == -1) {
            perror("setsockopt");
            exit(1);
        }

        if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("server: bind");
            continue;
        }

        break;
    }

    if (p == NULL)  {
        fprintf(stderr, "server: failed to bind\n");
        return 2;
    }

    freeaddrinfo(servinfo); // all done with this structure

    if (listen(sockfd, BACKLOG) == -1) {
        perror("listen");
        exit(1);
    }

    sa.sa_handler = sigchld_handler; // reap all dead processes
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(1);
    }

    printf("server: waiting for connections...\n");

    while(1) {  // main accept() loop
        sin_size = sizeof their_addr;
        new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
        if (new_fd == -1) {
            perror("accept");
            continue;
        }

        inet_ntop(their_addr.ss_family,
            get_in_addr((struct sockaddr *)&their_addr),
            s, sizeof s);
        printf("server: got connection from %s\n", s);

        if (!fork()) { // this is the child process
            close(sockfd); // child doesn't need the listener
            //if (send(new_fd, "Hello, world!", 13, 0) == -1)
            //    perror("send");
            //close(new_fd);
            StartMasterMind(new_fd,their_addr);
           // exit(0);
        }
        close(new_fd);  // parent doesn't need this
    }

    return 0;
}

void InitializeGame(const char* port)
{
    tcp_connect(port);
}

std::vector<color> GetInputAsColorMap(char* input)
{
[...]//redacted for clarity
}

int StartMasterMind(int client, sockaddr_storage addr_in) 
{
    struct msgstruct message;   
    struct sockaddr_storage their_addr = addr_in;
    socklen_t addr_len;

    message.send_data = "Welcome to ... M A S T E R M I N D.\n";
    message.length = strlen(message.send_data);
    send(client, message.send_data, message.length, 0);

[...]//redacted for clarity

    if (strcmp(theValue, "random") == 0 || strcmp(theValue, "Random") == 0)
    {
[...]//redacted for clarity
    }
    else
    {
[...]//redacted for clarity
    }


    char* buf;

    for (int i = 0; i < 8; ++i) {
        std::vector<color> current_try(4);
        int black_hits = 0, white_hits = 0;
        std::vector<int> correctColorIndex;
        std::vector<int> correctColor;

        bool exclude[4] = {false};
        std::cout << "test\n"; 
        message.send_data = "Please enter your guess:  ";
        message.length = strlen(message.send_data);
        send(client, message.send_data, message.length, 0);

        addr_len = sizeof their_addr;
        std::cout << "addr_len: " << addr_len << std::endl;     

        recvfrom(client, buf, MAXDATASIZE-1, 0, (struct sockaddr *)&their_addr, &addr_len);

        current_try = GetInputAsColorMap(buf);
        std::cout << "the buffer: " << buf << std::endl;
        std::cout << "current_try: " << current_try[0] << current_try[1] << current_try[2] << current_try[3] << std::endl;

[...]//redacted for clarity

        std::cout << black_hits << " black hits & " << white_hits
                    << " white hits.\n";

        if (black_hits == 4) {
            std::cout << "you won!\n";
            std::cin.ignore().get();
            close(client); //<<<< CRASH HERE
            return 0;
        }
    }   

[...]//redacted for clarity
}

int main(int argc, char** argv)
{
    InitializeGame(argv[1]);
    return 0;
}

这是样本输出：

server: waiting for connections...
server: got connection from 127.0.0.1
value or random: 
1122
test
addr_len: 128
the buffer: 1123�
current_try: 1123
3 black hits & 0 white hits.
test
addr_len: 128
the buffer: 1223�
current_try: 1223
2 black hits & 1 white hits.
test
addr_len: 128
the buffer: 1122�
current_try: 1122
4 black hits & 0 white hits.
you won!
accept: Bad file descriptor
accept: Bad file descriptor
accept: Bad file descriptor
... // continuously, hundreds of times

我对 socket 编程非常陌生，有人能帮我一下吗？即使在游戏结束时尝试关闭 client，这个程序也会崩溃。

2
如果显示“accept: Bad file descriptor”，那么在close（client）处"崩溃"，这肯定意味着问题出在accept。 - 0xF1
你说得对，抱歉 - 我对这个非常新，并且还没有弄清楚如何在gdb下有效地进行调试 - 但是，accept:应该已经暴露了它吧.. :) - MrDuk
2个回答
7

我认为当子进程回到while(1)循环的开头时，它会尝试使用已经被关闭了的sockfd服务器套接字描述符来accept一个连接：

if (!fork()) { // this is the child process
            close(sockfd);
....
}

尝试这个链接，了解如何在子进程完成工作后终止它。

1
我认为与上面的答案相同，可能是您没有关闭服务器套接字。在这种情况下，所有子进程都将尝试接受连接。或者您可能希望在子进程完成后退出。 - pmverma
我刚刚测试了注释掉 close(sockfd) 的代码，似乎可以工作！但这看起来很糟糕......在什么时候应该关闭 sockfd？ - MrDuk
1
因为服务器套接字正在接受连接，所以应该在代码的最后部分关闭套接字。就像在函数返回之前一样。 - pmverma
好的，那么可以安全地假设对于这么小的应用程序，我不需要担心关闭套接字（因为此时我的程序很可能会退出）吗？ - MrDuk
据我所知，如果你在程序中没有关闭文件描述符套接字，那么内核会在程序退出时关闭所有这些套接字。但最好还是将它们关闭。 - pmverma
2

这个消息意味着你正在对一个无效的文件描述符调用accept()，即可能是你已经关闭的文件描述符。

我撒谎了，看起来是我像@MadHatter建议的那样关闭了sockfd。 - MrDuk
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接