chatserv: Servidor de chat em C

Introdução

Recentemente verifiquei que existem problemas no script netchat que postei aqui há algum tempo. Outra coisa também é que ele utiliza o netcat padrão do slackware, a versão original do programa escrita por *Hobbit*. O Ubuntu e outras distribuições usam uma versão mais turbinada do netcat e ela não garante retrocompatibilidade com a versão usada no slackware.

Bem, pensando nisso, criei um programa em C que faz o papel do netchat: transportar mensagens para todo mundo conectado na mesma porta em um servidor. O bom é que esse programa em C tende a rodar em qualquer distribuição que tenha o gcc instalado.

Código do chatserv

Os comentários estão em inglês e foram escritos por mim a lá Joel Santana, por isso não repare muito na escrita. xD

/* charserv 1.0
 * by Daemonio (Marcos Paulo Ferreira)
 * undefinido gmail com
 *
 * chatserv
 * Handles incoming connections from (MAX_USERS)
 * users and redirect a message from an user
 * to all the others. I create this code
 * to play around on those boring classes on
 * college. Now they are more interesting.
 *
 * My first goal was to create a shell script
 * that would handle all connections using
 * netcat. I made the script but it seems that
 * every system I put my hands in has a
 * different version of nc.
 * So I code this simple server in C that will
 * run in all linux boxes with no problems,
 * and of course, to practice my select skills. :/
 *
 * How to use:
 * $ ./chatserv 2020
 *
 * Now the clients has to do:
 *
 * $ nc <server address> 2020
 *
 * To type in one terminal and see everything
 * you has received in another one:
 *
 * $ nc -lp 2021                                  (in console 1)
 * $ nc <server address> 2020 | nc localhost 2021 (in console 2)
 *
 * Now you will type your messages in console 2
 * and see what you got in console 1.
 *
 * If you a programmer you can easily create
 * a chat client that, for example, colorize
 * a message, transfer files, change nicks, etc ...
 * keep in mind that you have to create a
 * small protocol to facilitate the communication
 * between clients. (hey, isn't that the fun part??)
 *
 * Tue Oct 19 19:52:35 BRST 2010
 * Tue Oct 19 22:18:10 BRST 2010
 * Tue Oct 19 23:48:20 BRST 2010
 * Wed Oct 20 12:18:40 BRST 2010
 *
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/times.h>
#include <sys/select.h>
#include <unistd.h>

#define SERVER_BUSY "Sorry. The server is busy. bye\n"

#define MAX_USERS 20
#define MSG_LEN 4096

int socket_listening ;
/* for select() */
fd_set select_set ;

int  *list_of_sockets ;

int  max_users = MAX_USERS ;

/* grows up everytime an user
 * got a connection.
 * this variable stores the
 * current list size.*/
int  list_len = 0 ;

/* the user message */
char msg[MSG_LEN+1] ;

void show_help(char *name) {
printf("Chatserv 1.0\n") ;
printf("by Daemonio (undefinido gmail com)\n\n") ;
printf("[uso] %s <port> [<max_users>]\n", name) ;
}

/* if it's possible to insert a socket in
 * the list, this function returns 0 and
 * 1 otherwise.
 */
char insert_socket_into_list(int socket) {
    int i ;

    if ( list_len == max_users ) {
        return 1 ;
    }

    for ( i = 0; i < max_users; i++ ) {
        if ( list_of_sockets[i] == -1 ) {
            list_of_sockets[i] = socket ;
            list_len++ ;
            break ;
        }
    }
    return 0 ;
}

/* searches for a socket in the list
 * and closes it.
 */
void remove_socket_from_list(int _sock) {
    int i ;

    for ( i = 0; i < max_users; i++ ) {
        if ( list_of_sockets[i] == _sock ) {
            close(list_of_sockets[i]) ;
            list_of_sockets[i] = -1 ;
            list_len-- ;
            break ;
        }
    }
}

/* gets the message from an user.
 * this message will be in `msg'.
 * Returns 0 if the message was delivered
 * succesfully and 1 if the client
 * has finished the connection.
 */
char get_message_from_socket(int _sock) {
    int t ;

    memset(msg,0x0,MSG_LEN+1) ;
    t = recv(_sock, msg, MSG_LEN, 0 ) ;

    if ( t == 0 ) {
        remove_socket_from_list(_sock) ;
        return 1 ;
    }
    return 0 ;
}

/* after we got the message from the user,
 * we'll send it to all the others here.
 * note that an user cant send a message
 * to himself (list_of_sockets[i] != _sock).
 */
void send_message_to_all(int _sock) {
    int i ;

    for ( i = 0; i < max_users; i++ ) {
        if ( (list_of_sockets[i] != -1)    &&
             (list_of_sockets[i] != _sock) &&
             (list_of_sockets[i] != socket_listening) ) {

            send(list_of_sockets[i], msg, strlen(msg), 0) ;
        }
    }
}

int main(int argc, char **argv) {
    int port ;
    int t    ;

    struct sockaddr_in server ;
    struct timeval select_time ;

    if ( argc == 1 ) {
        show_help(argv[0]) ;
        return -1 ;
    }

    if ( argc > 2 ) {
        max_users = atoi(argv[2]) ;
    }

    port = atoi(argv[1]) ;

    socket_listening = socket(AF_INET, SOCK_STREAM, 0) ;

    if ( socket_listening < 0 ) {
        perror("socket") ;
        return -1 ;
    }

    server.sin_family = AF_INET ;
    server.sin_port = htons(port) ;
    server.sin_addr.s_addr = INADDR_ANY ;

    t = sizeof(struct sockaddr_in) ;
    if ( bind( socket_listening, (struct sockaddr *) &server, t ) < 0 ) {
        perror("bind") ;
        return -1 ;
    }

    if ( listen(socket_listening, 5) < 0 ) {
        perror("listen") ;
        return -1 ;
    }

    /* create the list of sockets.
     * for each client, there is a socket in this list.
     */
    list_of_sockets = (int *) malloc( max_users * sizeof(int) ) ;
    if ( list_of_sockets == NULL ) {
        perror("malloc") ;
        return -1 ;
    }

    /* "clean up" the list. */
    for ( t = 0; t < max_users; t++ )
        list_of_sockets[t] = -1 ;

    /* you'll need a ctrl+c to break this loop */
    while ( 1 ) {
        /* gets all the sockets and put in a
         * fd_set struct. */
        FD_ZERO(&select_set) ;
        FD_SET(socket_listening, &select_set) ;
        for ( t = 0; list_len > 0 && t < max_users; t++ ) {
            if ( list_of_sockets[t] != -1 ) {
                FD_SET(list_of_sockets[t], &select_set) ;
            }
        }

        printf("[+] Listening on %d [%d/%d] ...\n", port, list_len, max_users) ;

        /* select will wait 2 seconds before
         * returning. */
        select_time.tv_sec = 2 ;
        select_time.tv_usec = 0 ;

        /* select returns:
         * < 0 if error.
         * = 0 if nothing happened
         * > 0 number of sockets on the sets
         */
        if ( (t=select(FD_SETSIZE, &select_set, NULL, NULL, &select_time)) < 0 ) {
            perror("select") ;
            return -1 ;
        }

        /* wow, we have something ... */
        if ( t > 0 ) {
            /* if it's the listening socket, we have to
             * accept the incoming connection and add
             * the new socket in the list. */
            if ( FD_ISSET(socket_listening, &select_set) ) {
                int n ;

                if ( (n=accept(socket_listening, NULL, NULL)) < 0 ) {
                    perror("accept") ;
                } else if ( insert_socket_into_list(n) == 1 ) { /* server is busy */
                    send(n,SERVER_BUSY,strlen(SERVER_BUSY),0) ;
                    close(n) ;
                }
                continue ;
            } else {
                int i ;

                /* handle the incoming data. */
                for ( i = 0; i < max_users; i++ ) {
                    if ( FD_ISSET(list_of_sockets[i], &select_set) ) {
                        if ( get_message_from_socket(list_of_sockets[i]) == 0 ) {
                            send_message_to_all(list_of_sockets[i]) ;
                        }
                    }
                }
            }
        }
    } /* while */

    return 0 ;
} /* main */

Rodando o servidor

No caso do chat, alguém terá que rodar o servidor. Escolhido essa pessoa, ela deve compilar o chatserv:

$ gcc -o chatserv chatserv.c

Em seguida, rodar o programa. Escolha uma porta (ex: 31337) e a quantidade máxima de usuários (ex: 20):

$ ./chatserv 31337 20

O servidor está rodando. Agora só basta distribuir o IP do servidor e a porta. A porta é a 31337 como especificado, e o IP da máquina pode ser obtido pelo ifconfig:

$ ifconfig
....
eth0:
....
   inet addr: <seu ip está aqui>

….

Provavelmente aparecerá mais de uma interface, portanto mais de um ip. Geralmente o IP correto é o da interface eth0.

Os Clientes

Clientes são todos aqueles que conectarão no servidor. Mesmo se o chatserv estiver rodando em seu computador, você também terá que se conectar no servidor.

Para se conectar, digite:

$ nc <ip do servidor> 31337

O IP é aquele obtido pelo ifconfig. Se tudo estiver ok, as primeiras 20 pessoas que executarem o comando acima irão entrar no chat. De agora em diante todo mundo está ligado ao servidor e podem bater papo à vontade.

Dicas

1) Nick

O chatserv é um programa simples, pois ele só retransmite uma mensagem recebida para os outros usuários conectados nele. Logo, ele não é um programa de chat em si, pois não contém nem as funcionalidades básicas de um bate papo, como setar um nick. Usando ferramentas do linux, como o SED, podemos usar um nick no chat. Para isso, antes de se conectar no servidor, digite:

$ sed -u 's/.*/<seu nick>: &/' | nc localhost 31337

O SED deve ser chamado com a opção -u ativada (unbuffered) para que as mensagens não sejam bufferizadas antes de serem enviadas.

2) Descompartilhar terminal

Até então o mesmo terminal está sendo usado para digitar e receber as mensagens. Isso é muito ruim, pois pode acontecer de quando você estiver digitando uma mensagem, você receber outra, e tudo isso irá desvincular o que foi digitado com o restante da mensagem.

O ideal, então, é digitar as mensagens em um terminal e recebê-las em outro. Para fazer isso, só precisamos abrir dois terminais, um para compor e outro para receber as mensagens, e conectar a saída do chatserv com o terminal através de uma segunda porta.

Isto é:

• 1) Abra dois terminais (Konsole, gnome-terminal, etc)
• 2) No segundo, digite:

  $ nc -l 31338

• 3) Volte para o primeiro terminal e se conecte no servidor, acrescentando agora um pipe para redirecionar as mensagens para o terminal 2:

  $ sed -u 's/.*/<nick>: &' | nc <ip servidor> | nc localhost 31338

Agora sim. As mensagens são digitadas no terminal 1 e recebidas no terminal 2.

Printscreens

Alguns print screens para você ver como que fica o esquema do chat. Na primeira foto é minha situação antes de conectar. Abri os 2 terminais e só falta estabelecer a conexão.

Chatserv antes conectar

Esse screen é um exemplo de chat. No primeiro terminal é onde eu digito as mensagens. No terminal 2 eu as visualizo. Já o terminal 3, eu o abri somente para você ver como a situação completa do chat.

chatserv com o chat rolando

Conclusão

O chatserv funciona melhor do que o netchat e além disso é mais rápido, escrito em C, não usa fifos e arquivos temporários.

Então é isso.

t+