Sockets

[Dr_Lion]

Boa tarde a todos. Estou com uma dúvida em relação ao funcionamento deste tipo de comunicação.

Criei 2 programas, um cliente e um servidor em C, usando sockets.

No entanto a minha dúvida prende-se com a utilização correcta das sockets.

A ideia é receber no servidor cerca de 50 mensagens (cada mensagem é uma string de 50 caracteres), de cada cliente, o que faz um total de 150msgs por segundo a chegarem ao servidor.

O cenário suposto é ter um servidor, e 3 clientes.

As duas opções são:

-1 servidor com uma socket, e os 3 clientes a enviar dados para a mesma socket.

-1 servidor com 3 sockets, e cada cliente envia dados para uma socket diferente.

O que tenho a funcionar está na primeira opção, no entanto não sei se do ponto de vista da funcionalidade/eficiência se poderá existir perda de dados. Na utilização, eu não recebo quaisquer mensagens esquesitas, as que recebo estão todas correctas, não sei se não existarão mensagens incorrectas, ou se estas são descartadas.

Em relação á opção 2.

Agora queria comparar a primeira opção com a segunda e desenvolvi o seguinte código (apresento abaixo) no entanto tal como tenho o código, o servidor tem que receber as mensagens nas sockets por ordem. A minha pergunta é com alterar o código, para permitir por exemplo, uma socket receber várias mensagens, enquanto as outras sockets não receberam. Porque de momento, têm que receber todas as sockets uma mensagem, para passarem para a seguinte.

Cliente:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <math.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#define SERVER_IP "193.136.93.147"	
#define SERVERPORT "4950" // porto
#define MAXBUFLEN 100

int main(int argc, char *argv[])
{
int num =0;
int sockfd;
struct addrinfo hints, *servinfo, *p;
int rv;
int numbytes;
char mensagem[MAXBUFLEN];
char temp [33];

memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;

if ((rv = getaddrinfo(SERVER_IP, SERVERPORT, &hints, &servinfo)) != 0) {
 fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
 return 1;
}

// pesquisa os resultados e cria a socket
for(p = servinfo; p != NULL; p = p->ai_next) {
 if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
	 perror("talker: socket");
	 continue;
 }

 break;
 }

if (p == NULL) {
 fprintf(stderr, "clinete: failed to bind socket\n");
 return 2;
}

for(num=0; num<100; num++) {
temp[0]='\0';
mensagem[0]='\0';
strncpy(mensagem, "mensgem num x ", 14);
snprintf(temp, 33, "%d", num);
strncpy(mensagem+14, temp,33);
//mensagem[46]='\0';
printf("%s \n", mensagem);

if ((numbytes = sendto(sockfd, mensagem, strlen(mensagem), 0, p->ai_addr, p->ai_addrlen)) == -1) {
perror("cliente: a enviar");
exit(1);
}

//freeaddrinfo(servinfo);
}
close(sockfd);

return 0;
}

Servidor:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <math.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#define MYPORT "4950" // porto para os sensores se conectarem
#define MYPORT1 "4951"
#define MYPORT2 "4952"
#define MAX_EST 10
#define MAXBUFLEN 100
// obter o endereço do socket, ipv4 ou v6
void *get_in_addr(struct sockaddr *sa)
{
if (sa->sa_family == AF_INET) {
 return &(((struct sockaddr_in*)sa)->sin_addr);
}

return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

int main(void)
{
int sockfd;
int sockfd1, sockfd2; //a
struct addrinfo hints, *servinfo, *p;
struct addrinfo hints1, *servinfo1, *p1; //a
struct addrinfo hints2, *servinfo2, *p2; //a

int rv;
int rv1, rv2; //a
int numbytes;
int numbytes1, numbytes2; //a
struct sockaddr_storage their_addr;
struct sockaddr_storage their_addr1; //a
struct sockaddr_storage their_addr2; //a
char buf[MAXBUFLEN];
char buf1[MAXBUFLEN]; //a
char buf2[MAXBUFLEN]; //a
socklen_t addr_len;
socklen_t addr_len1; //a
socklen_t addr_len2; //a

//char s[iNET6_ADDRSTRLEN];

FILE *fich;

char sopo1[12]="socket 1: ";
char sopo2[12]="socket 2: ";
char sopo3[12]="socket 3: ";
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE;
memset(&hints1, 0, sizeof hints1);
hints1.ai_family = AF_UNSPEC;
hints1.ai_socktype = SOCK_DGRAM;
hints1.ai_flags = AI_PASSIVE;

memset(&hints2, 0, sizeof hints2);
hints2.ai_family = AF_UNSPEC;
hints2.ai_socktype = SOCK_DGRAM;
hints2.ai_flags = AI_PASSIVE;

if ((rv = getaddrinfo(NULL, MYPORT, &hints, &servinfo)) != 0) {
 fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
 return 1;
}
if ((rv1 = getaddrinfo(NULL, MYPORT1, &hints1, &servinfo1)) != 0) {
 fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv1));
 return 1;
}

if ((rv2 = getaddrinfo(NULL, MYPORT2, &hints2, &servinfo2)) != 0) {
 fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv2));
 return 1;
}

// bind no primeiro resultado que encontrar
for(p = servinfo; p != NULL; p = p->ai_next) {
 if ((sockfd = socket(p->ai_family, p->ai_socktype,
		 p->ai_protocol)) == -1) {
	 perror("listener: socket");
	 continue;
 }

 if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
	 close(sockfd);
	 perror("listener: bind");
	 continue;
 }

 break;
}


 // bind no primeiro resultado que encontrar
for(p1 = servinfo1; p1 != NULL; p1 = p1->ai_next) {
 if ((sockfd1 = socket(p1->ai_family, p1->ai_socktype,
		 p1->ai_protocol)) == -1) {
	 perror("listener: socket");
	 continue;
 }

 if (bind(sockfd1, p1->ai_addr, p1->ai_addrlen) == -1) {
	 close(sockfd1);
	 perror("listener: bind");
	 continue;
 }

 break;
}

 // bind no primeiro resultado que encontrar
for(p2 = servinfo2; p2 != NULL; p2 = p2->ai_next) {
 if ((sockfd2 = socket(p2->ai_family, p2->ai_socktype,
		 p2->ai_protocol)) == -1) {
	 perror("listener: socket");
	 continue;
 }

 if (bind(sockfd2, p2->ai_addr, p2->ai_addrlen) == -1) {
	 close(sockfd2);
	 perror("listener: bind");
	 continue;
 }

 break;
}


if (p == NULL) {
 fprintf(stderr, "listener: failed to bind socket\n");
 return 2;
}


if (p1 == NULL) {
 fprintf(stderr, "listener: failed to bind socket\n");
 return 2;
}


if (p2 == NULL) {
 fprintf(stderr, "listener: failed to bind socket\n");
 return 2;
}

freeaddrinfo(servinfo);

freeaddrinfo(servinfo1);
freeaddrinfo(servinfo2);

printf("listener: waiting to recvfrom...\n");


while(1) {
fich = fopen("test0", "a");

addr_len = sizeof their_addr;
if ((numbytes = recvfrom(sockfd, buf, MAXBUFLEN-1 , 0, (struct sockaddr *)&their_addr, &addr_len)) == -1) {
perror("recvfrom");
exit(1);
}
buf[numbytes] = '\0';
fprintf(fich, "%s %s\n",sopo1, buf);
printf("%s %s\n",sopo1, buf);



addr_len1 = sizeof their_addr1;
if ((numbytes1 = recvfrom(sockfd1, buf1, MAXBUFLEN-1 , 0, (struct sockaddr *)&their_addr1, &addr_len1)) == -1) {
perror("recvfrom");
exit(1);
}
buf1[numbytes1] = '\0';
fprintf(fich, "%s %s\n", sopo2, buf1);

addr_len2 = sizeof their_addr2;
if ((numbytes2 = recvfrom(sockfd2, buf2, MAXBUFLEN-1 , 0, (struct sockaddr *)&their_addr2, &addr_len2)) == -1) {
perror("recvfrom");
exit(1);
}
buf2[numbytes2] = '\0';
fprintf(fich, "%s %s\n",sopo3, buf2);

fclose(fich);
}


close(sockfd);
return 0;
}

Edited June 18, 2012 at 03:16 PM by Dr_Lion

[pikax]

Nao vi muito atentamente o teu problema nem o teu codigo.

Reparei que estas a usar UDP, e' porque e' obrigatorio ou e' porque queres, e' que seria mais facil com TCP.

1. podes meter cada cliente com uma ID e a primeira coisa da mensagem que o cliente manda e' o seu ID. Outra maneira funciona quando tem IP's diferentes, basta separar por IP.
   
2. Ja' tou um pouco enferrujado em sockets, mas se nao me engano os sockets tem que ser portas diferentes, podes criar um socket de conecao e depois enviar uma mensagem para os clientes enviarem para uma porta diferente.
   

[bsccara]

O servidor abre um socket e usa as funções bind() (para ligar a um interface e porta) e listen() (para poder aceitar ligações de clientes). Depois usa a função accept() para esperar (estou a assumir que o socket está em modo 'blocking') por uma ligação dum cliente. Quando houver uma a função accept() irá retornar com um novo socket para usar na comunicação com esse cliente, que poderás então iniciar.

Para trabalhares com vários clientes em simultâneo tens de paralelizar a chamada da função accept() com a transmissão e recepção de dados de sockets já ligados, seja usando a função select(), por forking (criando um processo para cada ligação, que correrão em paralelo), threads (criando uma thread para cada ligação aceite; menos pesado que usar processos) ou usando sockets assincronos (mais complexo mas com melhor performance). Vê esta e esta página para detalhes em Linux ou esta para Windows (Winsock2).

[Dr_Lion]

Peço desculpa por não ter referido, estou a usar ubuntu e sockets UDP, também me ocorreu a dúvida se não seria melhor usar sockets TCP, mas dos exemplos que vi na net, as sockets TCP pareciam-me bastante mais complicadas que as UDP e por isso escolhi UDP.

O código que postei aqui foi a tentativa da segunda opção; pois da primeira opção eu tenho o sistema a funcionar, mas detectei agora que com os 3 clientes a enviar para a mesma socket em udp em instantes muito próximos (sincronizei o relógio através do protocolo ntp e agendo o envio para o mesmo segundo) são recebidas todas as mensagens de 2 clientes, enquanto de um 3º apenas são recebidas 3 em 100.

Daí o meu interesse por uma solução para este problema.

bsccara:

Em relação á primeira página já tinha dado uma vista de olhos, em relação á segunda não, e vou ver agora. Já agora gostava de saber a tua opinião em relação ao protocolo a usar, TCP ou UDP. Pois do que falas pareceu-me ser sobre tcp e estava a usar udp. De qualquer forma já tinha pensado na hipótese de usar processos ou threads e parece-me ser a forma mais correcta de o fazer.

Sockets assíncronos se dizes ser mais complexo isso assusta-me, na realidade não necessito de grande performance, apenas não queria perder mensagens se estas forem enviadas em simultâneo.. e como estamos a falar de poucas mensagens por segundo não creio ser necessário.

Outra coisa, eu creio que estou a usar sockets não bloqueantes, que aliás é o que preciso. Sendo que usando TCP, é preciso mexer no fctl para as tornar não bloqueantes, e já uso isso para outro aspecto, não sei se terá interferências.

Desde já agradeço a todos

Edited June 19, 2012 at 12:35 PM by Dr_Lion

[HappyHippyHippo]

se mudares de UDP para TCP, esquece teres os 3 cliente ligados à mesma porta ...

para resolver o teu problema de vários clientes ligados à mesma porta (visto que não redireccionas os clientes para portas distintas como o FTP), terás de fazer a separação dos pacotes ao nível aplicacional. isto é, terás de implementar um protocolo

não te desiludas pelo nome porque um protocolo pode ser tão simples como (exemplo)

- 32 bytes (ip do cliente/servidor)

- 4 bytes : tamanho da mensagem em bytes

- mensagem

nota : um socket udp interpreta os dados como um stream. não existe o conceito de separação de dados como num datagrama de tcp. é por isso que existe os 4 bytes no protocolo que apresentei em cima.

[pikax]

Peço desculpa por não ter referido, estou a usar ubuntu e sockets UDP, também me ocorreu a dúvida se não seria melhor usar sockets TCP, mas dos exemplos que vi na net, as sockets TCP pareciam-me bastante mais complicadas que as UDP e por isso escolhi UDP.

TCP e' mais facil do que UDP, ja que as mensagens sao entregues na ordem que sao enviadas, enquanto no UDP nao ha' garantias que sejam entregues por ordem que sao enviadas, o UDP so' te da' certeza que ou chega o pacote ou nao chega nada!

mais informacoes em http://gafferongames.com/networking-for-game-programmers/udp-vs-tcp/

[bsccara]

nota : um socket udp interpreta os dados como um stream. não existe o conceito de separação de dados como num datagrama de tcp. é por isso que existe os 4 bytes no protocolo que apresentei em cima.

HHH, tens isso ao contrário. O TCP é que funciona como um stream de bytes, sem conceito de mensagens individuais. O UDP funciona por datagramas, um para cada mensagem.

Em termos de qual é o melhor, se a latência é um factor limitativo o UDP é melhor pois as mensagens são metidas logo na rede, enquanto que o TCP tenta agregar vários blocos (algoritmo de Nagle), se não encherem uma frame completa. E como o TCP trata de retransmissões, controlo de congestão e outras coisas é mais pesado na rede.

Mas o UDP não garante a entrega, ao contrário do TCP que retransmite até receber confirmação. Por isso o UDP é usado quando a latência tem de ser baixa mas a perda de alguns pacotes não é importante (tráfego interactivo, de vídeo ou voz).

Quanto ao que sugiro e já que usas sockets assincronos seria melhor estudares esse exemplo com o epoll(), que evita teres de andar a mexer em processamento paralelo, o que complica sem necessidade nesse caso. E como não precisas de latências baixas usa o TCP.

[Dr_Lion]

O servidor abre um socket e usa as funções bind() (para ligar a um interface e porta) e listen() (para poder aceitar ligações de clientes). Depois usa a função accept() para esperar (estou a assumir que o socket está em modo 'blocking') por uma ligação dum cliente. Quando houver uma a função accept() irá retornar com um novo socket para usar na comunicação com esse cliente, que poderás então iniciar.

Para trabalhares com vários clientes em simultâneo tens de paralelizar a chamada da função accept() com a transmissão e recepção de dados de sockets já ligados, seja usando a função select(), por forking (criando um processo para cada ligação, que correrão em paralelo), threads (criando uma thread para cada ligação aceite; menos pesado que usar processos) ou usando sockets assincronos (mais complexo mas com melhor performance). Vê esta e esta página para detalhes em Linux ou esta para Windows (Winsock2).

Boas, tentei ir pelo segundo site que me indicaste o epol, e ao olhar para o código não é fácil de compreender, no entanto, é fácil de observar que no final, usa o write para escrever no stdout.

Tentei de todas as maneiras que me ocorreram escrever para um ficheiro e o resultado foi simlpesmente desastroso. Com a própria função write diz file descriptor errado. Com o fwrite depois não consigo abrir o ficheiro, com o fprintf sim escreve para o ficheiro, mas algumas mensagens aparecem com falta de caracteres, ou caracteres excessivos. Confesso que já tenho a cabeça a ferver, passado duas horas a tentar escrever os resultados para um ficheiro e nada.

Deixo o código do servidor e do cliente no final.

Para o meu objectivo acho que vou abandonar esta opção e tentar mesmo o uso de threads ou processos, pois este código é algo extenso e complicado, e se para fazer uma simples escrita para um ficheiro é o fim do mundo, nem quero pensar para fazer algo mais..

No entanto gostaria de esclarecer a minha dúvida, se é possível imprimir o resultado para um ficheiro ou não? É que testei tal como o outro método, a ligar os 3 clientes em simultâneo, e apenas mostrou as mensagens de 1 dos clientes, os outros 2 não apareceram. E gostava de testar, a começarem em alturas diferentes, mas para isso preciso de um maior número de mensagens, e só é possível de testar se conseguir escrever os resultados num ficheiro.

Ambos compilam mas o servidor está a imprimir para o ecrâ, porque não consigo imprimir para um ficheiro.. será que alguém consegue?

Desde já agradeço a todos.

Servidor:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>
#define MAXEVENTS 64
#define MYPORT "4951"
#define MAXBUFLEN 100
static int make_socket_non_blocking (int sfd)
{
 int flags, s;
 flags = fcntl (sfd, F_GETFL, 0);
 if (flags == -1)
   {
  perror ("fcntl");
  return -1;
   }
 flags |= O_NONBLOCK;
 s = fcntl (sfd, F_SETFL, flags);
 if (s == -1)
   {
  perror ("fcntl");
  return -1;
   }
 return 0;
}
static int create_and_bind (char *port)
{
 struct addrinfo hints;
 struct addrinfo *result, *rp;
 int s, sfd;
 memset (&hints, 0, sizeof (struct addrinfo));
 hints.ai_family = AF_UNSPEC;	 /* Return IPv4 and IPv6 choices */
 hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
 hints.ai_flags = AI_PASSIVE;	 /* All interfaces */
 s = getaddrinfo (NULL, port, &hints, &result);
 if (s != 0)
   {
  fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
  return -1;
   }
 for (rp = result; rp != NULL; rp = rp->ai_next)
   {
  sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
  if (sfd == -1)
    continue;
  s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
  if (s == 0)
    {
	  /* We managed to bind successfully! */
	  break;
    }
  close (sfd);
   }
 if (rp == NULL)
   {
  fprintf (stderr, "Could not bind\n");
  return -1;
   }
 freeaddrinfo (result);
 return sfd;
}
int main (int argc, char *argv[])
{
 int sfd, s;
 int efd;
 struct epoll_event event;
 struct epoll_event *events;
 sfd = create_and_bind (MYPORT);
 if (sfd == -1)
   abort ();
 s = make_socket_non_blocking (sfd);
 if (s == -1)
   abort ();
 s = listen (sfd, SOMAXCONN);
 if (s == -1) {
perror ("listen");
abort ();
 }
 efd = epoll_create1 (0);
 if (efd == -1) {
   perror ("epoll_create");
   abort ();
 }
 event.data.fd = sfd;
 event.events = EPOLLIN | EPOLLET;
 s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
 if (s == -1) {
   perror ("epoll_ctl");
   abort ();
 }
 /* Buffer where events are returned */
 events = calloc (MAXEVENTS, sizeof event);
 /* The event loop */
 while (1) {
int n, i;
   n = epoll_wait (efd, events, MAXEVENTS, -1);
   for (i = 0; i < n; i++) {

  if ((events[i].events & EPOLLERR) ||(events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) {
    /* An error has occured on this fd, or the socket is not
		 ready for reading (why were we notified then?) */
 fprintf (stderr, "epoll error\n");
 close (events[i].data.fd);
 continue;
  } else if (sfd == events[i].data.fd)
 {
		  /* We have a notification on the listening socket, which
			 means one or more incoming connections. */
  while (1)
	    {
   struct sockaddr in_addr;
		    socklen_t in_len;
		    int infd;
		    char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
		    in_len = sizeof in_addr;
		    infd = accept (sfd, &in_addr, &in_len);
		    if (infd == -1)
		    {
 if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
			    {
				 /* We have processed all incoming connections. */
					  break;
			    } else
  {
					  perror ("accept");
					  break;
				    }
		    }
		    s = getnameinfo (&in_addr, in_len, hbuf, sizeof hbuf,sbuf, sizeof sbuf, NI_NUMERICHOST | NI_NUMERICSERV);
		    if (s == 0)
		    {
 printf("Accepted connection on descriptor %d "
						 "(host=%s, port=%s)\n", infd, hbuf, sbuf);
		    }
		    /* Make the incoming socket non-blocking and add it to the
			   list of fds to monitor. */
		    s = make_socket_non_blocking (infd);
		    if (s == -1)
 abort ();
		    event.data.fd = infd;
		    event.events = EPOLLIN | EPOLLET;
		    s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
		    if (s == -1)
		    {
 perror ("epoll_ctl");
			    abort ();
		    }
	    }
		  continue;
    } else
  {
		  /* We have data on the fd waiting to be read. Read and
			 display it. We must read whatever data is available
			 completely, as we are running in edge-triggered mode
			 and won't get a notification again for the same
			 data. */
		  int done = 0;
		  while (1)
		  {
   ssize_t count;
		    char buf[MAXBUFLEN];
		    count = read (events[i].data.fd, buf, sizeof buf);
		    if (count == -1)
		    {
		    /* If errno == EAGAIN, that means we have read all
				  data. So go back to the main loop. */
 if (errno != EAGAIN)
			    {
  perror ("read");
				    done = 1;
			    }
			    break;
		    } else if (count == 0)
			    {
				  /* End of file. The remote has closed the
					 connection. */
				  done = 1;
				  break;
			    }
		    /* Write the buffer to standard output */

   s = write (1, buf, count);
   if (s == -1)
   {
 perror ("write");
			    abort ();
		    }
 }
		  if (done)
		    {
			  printf ("Closed connection on descriptor %d\n", events[i].data.fd);
			  /* Closing the descriptor will make epoll remove it
				 from the set of descriptors which are monitored. */
			  close (events[i].data.fd);
		    }
	    }
    }
 }
 free (events);
 close (sfd);
 return EXIT_SUCCESS;
}

Cliente:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

#define SERVER_IP "193.136.93.147"
#define SERVERPORT "4951"    // porto
#define MAXBUFLEN 100
void error(const char *msg)
{
   perror(msg);
   exit(0);
}
int main(int argc, char *argv[])
{
   int sockfd, portno, n;
   struct sockaddr_in serv_addr;
   struct hostent *server;
   char buffer[MAXBUFLEN];
char temp [33];
int num;

   portno = atoi(SERVERPORT);
   sockfd = socket(AF_INET, SOCK_STREAM, 0);
   if (sockfd < 0)
    error("ERROR opening socket");
   server = gethostbyname(SERVER_IP);
   if (server == NULL) {
    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)
    error("ERROR connecting");
for(num=0; num<100; num++) {
 bzero(buffer, MAXBUFLEN);

  temp[0]='\0';
  buffer[0]='\0';
  strncpy(buffer, "client3 num x ", 14);
  snprintf(temp, 33, "%d", num);
  strncpy(buffer+14, temp,8);
  buffer[strlen(buffer)]='\n';
  printf("%s", buffer);


 n = write(sockfd,buffer,strlen(buffer));
 if (n < 0)
   error("ERROR writing to socket");
}
   close(sockfd);
   return 0;
}

[bsccara]

É perfeitamente possível gravar para um ficheiro. Estou a limpar o código que postaste e a testá-lo (também tenho interesse nisto).