Server with multiple clients and timing

[nevixa]

Hello all,

I want to make a 'monitoring' server that can have multiple connections (over network) and measures if a client is up/down. So every client sends his ID to the server and when the server does not receive an ID for more then 30 seconds, the client is down.

The client and server are working, the only problem with the server is that it only continues when an ID is coming in from a client. So the server only measures time when a client is sending him something. So if all clients are down, the server will not know because he wouldn't measure time because he receives nothing. Basically I think I just placed the while loop in the wrong place, but I just can't figure it out.

Server code is below.

void dostuff(int); /* function prototype */

void error(const char *msg) {
    perror(msg);
    exit(1);
}

int main(int argc, char *argv[]) {
    cvInitFont(&font3, CV_FONT_HERSHEY_SIMPLEX, 0.6f, 0.6f, 0, 2); //initiate font

    int sockfd, newsockfd, portno, pid;
    socklen_t clilen;
    struct sockaddr_in serv_addr, cli_addr;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
        error("ERROR opening socket");
    bzero((char *) &serv_addr, sizeof (serv_addr));
    portno = 2010;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(portno);
    if (bind(sockfd, (struct sockaddr *) &serv_addr,
            sizeof (serv_addr)) < 0)
        error("ERROR on binding");
    listen(sockfd, 5);
    clilen = sizeof (cli_addr);

    time_t start,end;
    time (&start);
    double difTime;
   
    do {
        time (&end);
        difTime = difftime(end,start);
        cout << "difTime " << difTime << endl;

        newsockfd = accept(sockfd,
                (struct sockaddr *) &cli_addr, &clilen);
            
        if (newsockfd < 0)
            error("ERROR on accept");
        pid = fork();
        if (pid < 0)
            error("ERROR on fork");
        if (pid == 0) {
            close(sockfd);
            dostuff(newsockfd);
            exit(0);
        } else close(newsockfd);

    } while (1); 
    close(sockfd);
   return 0; /* we never get here */
}

void dostuff(int sock) {
    int n;
    char buffer[256];

    memset(buffer,0, 256);
    n = read(sock, buffer, 255);
    if (buffer == "1") diip1Counter = 0;
    if (n < 0) error("ERROR reading from socket");
    printf("%s\n", buffer);
    n = write(sock, "I got your message", 18);
    if (n < 0) error("ERROR writing to socket");
}

And the client side:

void error(const char *msg) {
    perror(msg);
}

int monitor() {
    int communicationFailed = 0;
    int sockfd, portno, n;
    struct sockaddr_in serv_addr;
    struct hostent *server;

    char buffer[256];
    portno = 2010;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        error("ERROR opening socket");
        communicationFailed = 1;
    }
    server = gethostbyname("10.56.162.8");
    if (server == NULL) {
        communicationFailed = 1;
        fprintf(stderr, "ERROR, no such host\n");
        exit(0);
    }
    bzero((char *) &serv_addr, sizeof (serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *) server->h_addr,
            (char *) &serv_addr.sin_addr.s_addr,
            server->h_length);
    serv_addr.sin_port = htons(portno);

    if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) {
        communicationFailed = 1;
        error("ERROR connecting");
    }
    n = write(sockfd, "1", 1);
    if (n < 0) {
        communicationFailed = 1;
        error("ERROR writing to socket");
    }
    bzero(buffer, 256);
    n = read(sockfd, buffer, 255);
    if (n < 0)
        error("ERROR reading from socket");
    printf("%s\n", buffer);
    close(sockfd);
    return communicationFailed;
}

Thank you for your time!

[kooth]

Well, your server will only do anything when it detects a new connection. Your server loop is in the right place. Perhaps you will need a separate server thread to run and periodically connect to itself.