#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
 
    #define MYPORT 3490    /* the port users will be connecting to */
 
    #define BACKLOG 100     /* how many pending connections queue will hold */
 
    main()
    {
        int sockfd, new_fd;  /* listen on sock_fd, new connection on new_fd */
        struct sockaddr_in my_addr;    /* my address information */
        struct sockaddr_in their_addr; /* connector's address information */
        int sin_size;
 
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
            perror("socket");
            exit(1);
        }
 
        my_addr.sin_family = AF_INET;         /* host byte order */
        my_addr.sin_port = htons(MYPORT);     /* short, network byte order */
        my_addr.sin_addr.s_addr = inet_addr ("127.0.0.1"); /* auto-fill with my IP */
        memset(&(my_addr.sin_zero),'\0', 8);        /* zero the rest of the struct */
 
 
 
        if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1){
            perror("Bind");
            exit(1);
        }
 
        if (listen(sockfd, BACKLOG) == -1) {
            perror("listen");
            exit(1);
        }
 
        while(1) {  /* main accept() loop */
            sin_size = sizeof(struct sockaddr_in);
            if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, \
                                                          &sin_size)) == -1) {
                perror("accept");
                continue;
            }
            printf("server: got connection from %s\n", \
                                               inet_ntoa(their_addr.sin_addr));
            if (!fork()) { /* this is the child process */
                if (send(new_fd, "Va el puñetero programaaaaa!\n", 100, 0) == -1)
                    perror("send");
                close(new_fd);
                exit(0);
            }
            close(new_fd);  /* parent doesn't need this */
 
            while(waitpid(-1,NULL,WNOHANG) > 0); /* clean up child processes */
        }
    }

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
 
    #define PORT 3490    /* the port client will be connecting to */
 
    #define MAXDATASIZE 100 /* max number of bytes we can get at once */
 
    int main(int argc, char *argv[])
    {
        int sockfd, numbytes; 
        char buf[MAXDATASIZE];
        struct hostent *he;
        struct sockaddr_in their_addr; /* connector's address information */
 
        if (argc != 2) {
            fprintf(stderr,"usage: client hostname\n");
            exit(1);
        }
 
        if ((he=gethostbyname(argv[1])) == NULL) {  /* get the host info */
            error("gethostbyname");
            exit(1);
        }
 
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
            perror("socket");
            exit(1);
        }
 
        their_addr.sin_family = AF_INET;      /* host byte order */
        their_addr.sin_port = htons(PORT);    /* short, network byte order */
        their_addr.sin_addr = *((struct in_addr *)he->h_addr);
        bzero(&(their_addr.sin_zero), 8);     /* zero the rest of the struct */
 
        if (connect(sockfd, (struct sockaddr *)&their_addr, \
                                              sizeof(struct sockaddr)) == -1) {
            perror("connect");
            exit(1);
        }
 
        if ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1) {
            perror("recv");
            exit(1);
        }
 
        buf[numbytes] = '\0';
 
        printf("Received: %s",buf);
 
        close(sockfd);
 
        return 0;
    }

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
 
#define MYPORT 3490    /* the port users will be connecting to */
#define BACKLOG 100   
#define CONEXIONES 5 
 
int numero_de_hijos = 0;
 
void proceso_hijo( int socket_servidor)
{	
   fd_set grupo, grupo_todos; 
   int maxfd = socket_servidor;
   int ceiling = 0;
   int i;
 
   FD_ZERO(&grupo);
   FD_ZERO(&grupo_todos);
 
   FD_SET(socket_servidor, &grupo_todos);
 
   while(1)
   {
      grupo = grupo_todos;
 
      if ( select(maxfd+1, &grupo, 0, 0, 0) > 0 )
      {
         for ( i = 0; i < maxfd + 1; ++i)
         {
            if ( FD_ISSET(i, &grupo) )
            {
               if ( i == socket_servidor )
               {
                  if ( ceiling < CONEXIONES )
                  { 
		             int client = accept(socket_servidor, 0, 0);
		             if ( maxfd < client )
		                maxfd = client;
                             FD_SET(client, &grupo_todos);//lo añadimos al grupo
		             ceiling++;
		             printf("select proceso #%d: %d conexiones\n", getpid(), ceiling);
		          }//fin si
		       }	
		       else
                       {
                          char buffer[1024];
		          int bytes;
 
                          memset (buffer, '\x0', sizeof(buffer)); 
		          bytes = recv(i, buffer, sizeof(buffer), 0);
 
		          printf ("El cliente %d nos envia: %s\n", i - 3, buffer);
 
		          if ( bytes == 0 )
                         {
                             close(i);
		             FD_CLR(i, &grupo_todos);//lo quitamos del grupo
		             ceiling--;
		             printf("select process #%d: %d conexiones\n",
			         getpid(), ceiling);
		          }
                         else	/* enviamos al cliente lo mismo que recibimos (servidor de eco)*/
	                    send(i, buffer, bytes, 0);
               }//fin else
            }//fin si(FD_ISSET)                  
         } //fin for     
      }//fin si (select)         
 
   }//fin while(1)
   exit(0);     
}// fin 'proceso_hijo' 
 
 
   main()
    {
         int sock, pid;
  	struct sockaddr_in local;
  	struct hostent *dir_server;
  	socklen_t len;
 
 
	int sockfd, new_fd;  /* listen on sock_fd, new connection on new_fd */
        struct sockaddr_in my_addr;    /* my address information */
        struct sockaddr_in their_addr; /* connector's address information */
        int sin_size;
 
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
            perror("socket");
            exit(1);
        }
 
        my_addr.sin_family = AF_INET;         /* host byte order */
        my_addr.sin_port = htons(MYPORT);     /* short, network byte order */
        my_addr.sin_addr.s_addr = inet_addr ("127.0.0.1"); /* auto-fill with my IP */
        memset(&(my_addr.sin_zero),'\0', 8);        /* zero the rest of the struct */
 
if (bind(sock, (struct sockaddr *) &local, sizeof(local)) == 0)
  {
     listen(sock, CONEXIONES);  
     while (1)
     {
        if (numero_de_hijos < CONEXIONES)
        {
           if ((pid = fork()) == 0) 
              proceso_hijo(sock); 
           else if (pid > 0)
              numero_de_hijos++;
           else
              perror("fork");                  
        }//fin si    
        else 
           sleep(1);     
     }//fin while(1)
   }//fin si (bind)
   else
      perror("bind");
   return 0;
}//fin main