Programando/tratando Sockets em C
                            por Luís Miguel Silva

a) Para este *tutorial*, vou apresentar três funções usadas para o 
*tratamento* de sockets e explica-las passo a passo...

   int openhost(char *host, int port);
   void sends(int sock,char *buf);
   void receive(int sock,char *buf);

b) Analisando as três funções...(openhost,sends,receive);

/***************** BEGUINNING OF FUNCTIONS ***********************/

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

// *Abrir* a socket...(usando tcp/ip como protocolo...)

int openhost(char *host,int port) {
   int sock;
   // estrutura que vai conter *várias informações* sobre a socket bindada
   struct sockaddr_in addr;
   // estrutura que vai *recolher* informações sobre o host *aberto*
   struct hostent *he;
      
   // *tentar* recolher informação sobre o determinado host (passado como
   // parametro)
   he=gethostbyname(host);
   
   if (he==NULL) {
      // Host doesnt exist or something =)
      perror("gethostbyname()");
      exit(-1); }
   
    // criar um *endpoint* para a comunicação...
    // em termos para leigos...abrir a socket :P
    sock=socket(AF_INET, SOCK_STREAM, getprotobyname("tcp")->p_proto);
    
    if (sock==-1) {
       // Se o resultado da chamado à função anterior for "-1", então
       // não foi possivel *abrir* a socket :|
       perror("socket()");
       exit(-1); }
    
    // Nesta fase, *atribuimos* a informação recolhida pela struct *he do tipo
    // hostent, pela chamada à função "gethostbyname()", à outra struct addr
    // do tipo sockaddr_in
    memcpy(&addr.sin_addr, he->h_addr, he->h_length);
    // *dizer* à struct addr, que queremos usar os "ARPA internet protocols"
    addr.sin_family=AF_INET; 
    // atribuir à struct addr, a *porta* a que nos queremos ligar
    // *convertendo* os valores entre o host e o network pela *ordem de bytes*
    addr.sin_port=htons(port); 
    // *fim* das atribuições à nossa 2ª estrutura *addr (do tipo sockaddr_in)
    
    // *finalmente*...vamos tentar connectarmo-nos, usando as informações
    // recolhidas... :)
    // int connect(int sockfd,struct sockaddr *serv_addr, int addrlen);
    if(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
       // Se o retorno da chamada à função anterior for "-1", então
       // Não foi possivel connectar :/
       perror("connect()"); 
       exit(-1); }

    // Finalmente...retornar a socket para uso *posterior* ;)
    return sock;
}

/* Depois de termos *aberto o host*, podemos comunicar com ele, usando
   as duas funções abaixo =) */

// enviar uma string...

void sends(int sock,char *buf) {
  // escreve(para o socket aberto, a string buf, tamanho da string);
  write(sock,buf,strlen(buf));
}


// receber uma string...

void receive(int sock, char *buf) {
  // Para recebermos uma string do host a que estamos ligados...de uma forma
  // *segura*, le-mos char a char...até encontrarmos um "\n" (*supostamente*,
  // mudança de linha e...END OF STRING :]
  int i=0;
  char rechar[2];
  while(rechar[0]!='\n') { // esperar pelo "\n"
     read(sock,rechar,1); // ler um char do socket aberto...
     strcpy(buf+i,rechar); // *acrescentar* o char lido à nossa string =)
     buf[i+1] = 0;
     i++; }
}

/***************** END OF FUNCTIONS ***********************/

E aqui acabamos o nosso pequeno *tutorial* de como *tratar* sockets :]
Espero que tenha *ajudado* alguém! :P
Btw, se encontrares alguma coisa de errado nas minhas explicações, feel
free to mail me at lms@ispgaya.pt



                                         -  http://lms.ispgaya.pt/ -