错误 - 接受（）失败：错误的文件描述符

Question

I have to implement two processes that have to interact through TCP, basically a file transfer between a server and a client (school homework). Everything work for the first file transmission but when the client ends its job the server crashes because of error - accept() failed: Bad file descriptor .

server_main.c

int main (int argc, char *argv[]) {

    char cwd[100];

    if (getcwd(cwd, sizeof(cwd)) != NULL) {
       printf("App[starting]: " ANSI_COLOR_CYAN "%s" ANSI_COLOR_RESET "\n", cwd);
    } else {
       printf("App[quitting]: " ANSI_COLOR_RED "UNABLE TO LOCATE WDIR" ANSI_COLOR_RESET "\n");
       return 1;
    }

    // procedo solo se vengono passati esattamente due parametri allo script
    // 1. il nome dello script (default)
    // 2. la porta
    if (argc == 2) {
        int passiveSocket = startTcpServer(argv[1]);
        runIterativeTcpInstance(passiveSocket);
        close(passiveSocket);
        return 0;
    }

    // se arrivo qui ho app crash
    printf("App[quitting]: " ANSI_COLOR_RED "USAGE: <PORT>" ANSI_COLOR_RESET "\n");

    return 1;
}

gj_server.c

int startTcpServer(const char* port) {

    uint16_t i_port;
    int sockfd;

    sockfd = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    parsePort(port, &i_port);
    bindToAny(sockfd, i_port);
    Listen(sockfd, 516);
    printf("Server[listening]: " ANSI_COLOR_GREEN "PORT = %d, BACKLOG = 516" ANSI_COLOR_RESET "\n", (int) i_port);

    return sockfd;
}

void runIterativeTcpInstance(int passiveSock) {

    struct sockaddr_in cli_addr;
    socklen_t addr_len = sizeof(struct sockaddr_in);

    while(1) {
        printf("Server[accepting]: " ANSI_COLOR_YELLOW "WAITING FOR A CONNECTION..." ANSI_COLOR_RESET "\n");
        int connSock = Accept(passiveSock , (struct sockaddr *) &cli_addr, &addr_len);
        doTcpJob(connSock);
        close(connSock);
    }

}

void doTcpJob(int connSock) {
    //TODO: uscire in caso di errore di una delle due fasi
    printf("Server[connection]:" ANSI_COLOR_GREEN "STARTED A NEW ON CONNECTION (PID=%d)" ANSI_COLOR_RESET "\n", getpid());
    char request[256];
    initStr(request, 256);
    if(doTcpReceive(connSock, request) == 0)
        doTcpSend(connSock, request);
    else {
        printf("Server[error]: " ANSI_COLOR_RED "INVALID REQUEST FROM CLIENT: %s" ANSI_COLOR_RESET "\n", request);
        char err_buff[7] = "-ERR\r\n";
        send(connSock, err_buff, 6, 0);
        //close(connSock);
    }

//close(connSock); }

int doTcpReceive(int connSock, char *request) {

    struct timeval tval;
    fd_set cset;
    FD_ZERO(&cset);
    FD_SET(connSock, &cset);
    tval.tv_sec = 15;
    tval.tv_usec = 0;
    if(Select(FD_SETSIZE, &cset, NULL, NULL, &tval) == 1) {
        // TODO: INSERIRE LOGICA RECEIVE QUI
        ssize_t read = 0;
        while (reqCompleted(request) == -1 ) {
         ssize_t received = Recv(connSock, request, 256, 0); 
         read += received;
        }
        printf("Server[receive]: " ANSI_COLOR_CYAN "RECEIVED %s" ANSI_COLOR_RESET "\n", request);
        return checkRequest(request);
    }
    // esco per timeout
    //close(connSock);
    return -1;
}

void doTcpSend(int connSock, char *request) {
    // TODO: INSERIRE LOGICA SEND QUI

    // 1. send ok message
    char ok_msg[6] = "+OK\r\n";
    send(connSock, ok_msg, 5, 0);

    // 2. send file size
    FILE *fp = fopen(request, "rb+");

    // qui il file dovrebbe esistere, ma potrebbe essere inacessibile o
    // l'apertura potrebbe fallire
    if (fp == NULL) {
        printf("SERVER[READING]" ANSI_COLOR_RED "CANNOT OPEN FILE %s " ANSI_COLOR_RESET "\n", request);
        char err_buff[7] = "-ERR\r\n";
        send(connSock, err_buff, 6, 0);
        //close(connSock);
        return;
    }

    struct stat stat_buf;

    if (fstat(fileno(fp), &stat_buf) == 0) {

        long f_size = stat_buf.st_size;
        long f_time = stat_buf.st_mtime;
        uint32_t net_f_size = htonl(f_size);
        send(connSock, &net_f_size, 4, 0);

        // 3. send file content
        ssize_t sent = 0;
        printf("fsize: %d", (int)f_size);
        while (sent < f_size) {
            sent += sendfile(connSock, fileno(fp), NULL, f_size);
            showProgress((int)sent, (int)f_size, "Server[sending]: ");
        }

        fclose(fp);

        // 4. send file timestamp
        uint32_t net_f_time = htonl(f_time);
        send(connSock, &net_f_time, 4, 0); 
        //close(connSock);

    } else {
        char err_buff[7] = "-ERR\r\n";
        send(connSock, err_buff, 6, 0);
        //close(connSock);
        return;
    }


}

int reqCompleted(char *request) {
    int len = strlen(request);
    return len > 6 && request[len - 2] == '\r' && request[len - 1] == '\n' ? 0 : -1;
}

int checkRequest(char *request) {
    int len = strlen(request);
    if (len > 6 && request[0] == 'G' && request[1] == 'E' && request[2] == 'T'
        && request[3] == ' ' && request[len - 2] == '\r' && request[len - 1] == '\n') {
            memcpy(request, request + 4, (len - 6)); // estraggo il nome del file dalla richiesta
            request[len - 6] = '\0';
            return access(request, F_OK); // verifico che il file esista nella cartella di lavoro
        }
    return -1;
}

the parameter called passiveSock causes the problem, at the second iteration of the while loop, I'm quite new in C and I think it's relative to life cycle of a variable. I've already tried to print passiveSock before the accept call and gives me an error. This is the valgrind output:

==1== Syscall param accept(s) contains uninitialised byte(s)
==1==    at 0x4F21990: __accept_nocancel (syscall-template.S:84)
==1==    by 0x10A7D4: Accept (sockwrap.c:97)
==1==    by 0x109AA5: runIterativeTcpInstance (gj_server.c:28)
==1== 
((null)) error - accept() failed: Bad file descriptor
==1== 
==1== HEAP SUMMARY:
==1==     in use at exit: 0 bytes in 0 blocks
==1==   total heap usage: 2 allocs, 2 frees, 1,576 bytes allocated
==1== 
==1== All heap blocks were freed -- no leaks are possible
==1== 
==1== For counts of detected and suppressed errors, rerun with: -v
==1== Use --track-origins=yes to see where uninitialised values come from
==1== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)

EDIT sockwrap.c Accept definition

int Accept (int listen_sockfd, SA *cliaddr, socklen_t *addrlenp)
{
    int n;
again:
    if ( (n = accept(listen_sockfd, cliaddr, addrlenp)) < 0)
    {
        if (INTERRUPTED_BY_SIGNAL ||
            errno == EPROTO || errno == ECONNABORTED ||
            errno == EMFILE || errno == ENFILE ||
            errno == ENOBUFS || errno == ENOMEM         
            )
            goto again;
        else
            err_sys ("(%s) error - accept() failed", prog_name);
    }
    return n;
}

initStr and showProgress

void initStr(char* string, int length) {
    memset(string, '\0', length);
    string[length] = '\0';
}

void showProgress(int done, int tot, char * progMsg) {
    int progress = ((double) done / (double) tot) * 100;
    printf("\r%s " ANSI_COLOR_CYAN "%d bytes (%d%%)" ANSI_COLOR_RESET, progMsg, done, progress);
    fflush(stdout);
}

Answer 1

Of course the bug was in the first function I wanted to check. Look closely:

    void initStr(char* string, int length) {
        memset(string, '\0', length);
        string[length] = '\0'; // <-- BOOM!
    }

But:

    char request[256];
    initStr(request, 256);

So request is an array with 256 entries. But initStr writes into the 257th entry, which does not exist.

You should get rid of this function and never use anything even remotely like it. Filling an entire buffer with zeroes serves no purpose. Instead, properly track the length of the data in the buffer and stop calling strlen all the time. There are other bugs in your code because of this, much more subtle ones.

For example, you try to read 256 bytes from the connection. This could fill your entire buffer, replacing all the zero bytes. You then pass the buffer to strlen -- but there is no guarantee there is a zero byte anywhere in the buffer.

Data received over a network connection is not a string. It's raw data with a known length that is returned from the read or recv function. Don't pretend it is a string. It's a bad habit that will bite you again and again and again.