listen() does not block process

Question

EDIT: nevermind! I spent hours trying to get the error... I was using connect() instead of accept()... Shame on me.

EDIT 2: I'd like to specify that this code might have no sense, this is because I'm currently studying the subject and what you find in this page is one of my very first tests. Thank you!

This is the code of a very simple server that I'm writing... I can't understand why the listen() function doesn't block the process which goes straight ahead to the connect() which fails giving me error 22 - Invalid argument. What's the problem? Thank you.

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <errno.h>

#define BUFMAXSIZE 1024
#define MAXLISTEN 10
#define SOCKERROR -1

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

    int localPort;

    int sockfd, sockbind, socklist, sockaccept;
    struct sockaddr_in local, remote;
    int remoteSize;

    char readMsg[BUFMAXSIZE];
    int totalReadLen, singleLoopRead;

    char answer[BUFMAXSIZE];
    int totalSentLen, singleLoopSent, answerLen;

    // Checking parameters
    if(argc < 2) {
        printf("Usage: server LOCAL_PORT_NUMBER\n");
        exit(1);
    }
    else {
        localPort = atoi(argv[1]);
    }

    // Creating socket
    printf("Creating socket...\n");
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd == SOCKERROR) {
        printf("Error: could not open socket.\n");
        exit(1);
    }
    printf("Socket created.\n");

    // Setting local information
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = htonl(INADDR_ANY);
    local.sin_port = htons(localPort);

    // Binding
    printf("Setting local information...\n");
    sockbind = bind(sockfd, (struct sockaddr*) &local, sizeof(local));
    if(sockbind == SOCKERROR) {
        printf("Error: could not bind socket.\n");
        exit(1);
    }
    printf("Socket binded.\n");

    // Listening
    printf("Listening on %d:%d...\n", ntohl(local.sin_addr.s_addr), ntohs(local.sin_port));
    socklist = listen(sockfd, MAXLISTEN);
    if(socklist == SOCKERROR) {
        printf("Error: could not listen.\n");
        exit(1);
    }

    // Accepting connection
    printf("Accepting connection...\n");
    memset(&remote, 0, sizeof(remote));
    remoteSize = sizeof(remote);
    sockaccept = connect(sockfd, (struct sockaddr*) &remote, &remoteSize);
    if(sockaccept == SOCKERROR) {
        printf("Error: could not accept connection.\n");
        exit(1);
    }
    printf("Connection accepted.\n");

    // Reading data
    printf("Reading data...\n");
    totalReadLen = 0;
    singleLoopRead = 0;
    while(BUFMAXSIZE > totalReadLen && (singleLoopRead = read(sockaccept, &(readMsg[totalReadLen]), BUFMAXSIZE - totalReadLen)) > 0) {
        totalReadLen += singleLoopRead;
        if(singleLoopRead < 0) {
            printf("Error: could not read data.\n");
            exit(1);
        }
        else {
            printf("Data read: %d.\n", singleLoopRead);
        }
    }
    printf("Read message: %s.", readMsg);

    // Sending answer
    printf("Sending answer...");
    totalSentLen = 0;
    singleLoopSent = 0;
    strncpy(answer, "Data have been received.", BUFMAXSIZE - 1);
    answerLen = strlen(answer);
    fflush(stdout);
    while((singleLoopSent = write(sockaccept, &(answer[totalSentLen]), answerLen - totalSentLen)) > 0) {
        totalSentLen += singleLoopSent;
        if(singleLoopSent < 0) {
            printf("Error: could not send answer.\n");
            fflush(stdout);
            exit(1);
        }
        else {
            printf("Total data sent: %d bytes.\n", totalSentLen);
        }
    }
    fflush(stdout);
    printf("Answer correctly sent.\n");

    // Closing sockets
    printf("Closing connection...\n");
    close(sockaccept);
    close(sockfd);
    printf("Connection closed.\n");

    return 0;
}

Answer 1

I can't understand why the listen() function doesn't block the process

Because it isn't a blocking function. It puts the port into the LISTEN state. It is accept() which is the blocking function, which you should be calling next.

which goes straight ahead to the connect() which fails giving me error 22 - Invalid argument.

Because the socket is in LISTEN state, because you called listen(). You can't connect a listening socket. You should be calling accept().

What's the problem?

The problem is that your code doesn't make sense.