Программирование сетевых приложений (TCP/IP) на C/C++

/* определяет типы данных */
#include <sys/types.h>
/* "Главный" по сокетам */
#include <sys/socket.h>
/* sockaddr_in struct, sin_family, sin_port, in_addr_t, in_port_t, ...*/
#include <netinet/in.h>

#include <stdio.h>
#include <memory.h>
#include <string.h>
#include <errno.h>

/**@brief Получает от клиента последовательность байт, не длиннее 30 и печатает её на экран по
 * завершении соединения. Клиенту отправляет "Hi, dear!"*/
int main(int argc, char * argv)
{
      /*создаём сокет*/
      int s = socket(AF_INET, SOCK_STREAM, 0);
      if(s < 0)
      {
              perror("Error calling socket");
              return 0;
      }

      /*определяем прослушиваемый порт и адрес*/
      struct sockaddr_in addr;
      addr.sin_family = AF_INET;
      addr.sin_port = htons(18666);
      addr.sin_addr.s_addr = htonl(INADDR_ANY);
      if( bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0 )
      {
              perror("Error calling bind");
              return 0;
      }

      /*помечаем сокет, как пассивный - он будет слушать порт*/
      if( listen(s, 5) )
      {
              perror("Error calling listen");
              return 0;
      }

      /*начинаем слушать, для соединения создаём другой сокет, в котором можем общаться.*/
      int s1 = accept(s, NULL, NULL);
      if( s1 < 0 )
      {
              perror("Error calling accept");
              return 0;
      }

      /*читаем данные из сокета*/
      char buffer[31];
      int counter = 0;
      for(;;)
      {
              memset(buffer, 0, sizeof(char)*31);
              /*следует помнить, что данные поступают неравномерно*/
              int rc = recv(s1, buffer, 30, 0);
              if( rc < 0 )
              {
                      /*чтение может быть прервано системным вызовом, это нормально*/
                      if( errno == EINTR )
                              continue;
                      perror("Can't receive data.");
                      return 0;
              }
              if( rc == 0 )
                      break;
              printf("%s\n", buffer);
      }
      char response[] = "Hi, dear!";
      if( sendto( s1, response, sizeof(response), 0, (struct sockaddr *)&addr, sizeof(addr) ) < 0 )
              perror("Error sending response");
      printf("Response send\n");
      return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
/* hton, ntoh и проч. */
#include <arpa/inet.h>
#include <memory.h>
#include <stdio.h>

int main(int argc, char * argv[])
{

      /*объявляем сокет*/
      int s = socket( AF_INET, SOCK_STREAM, 0 );
      if(s < 0)
      {
              perror( "Error calling socket" );
              return 0;
      }

      /*соединяемся по определённому порту с хостом*/
      struct sockaddr_in peer;
      peer.sin_family = AF_INET;
      peer.sin_port = htons( 18666 );
      peer.sin_addr.s_addr = inet_addr( "127.0.0.1" );
      int result = connect( s, ( struct sockaddr * )&peer, sizeof( peer ) );
      if( result )
      {
              perror( "Error calling connect" );
              return 0;
      }

      /*посылаем данные
       *
       * Если быть точным, данные не посланы, а записаны где-то в стеке, когда и как они будут
       * отправлены реализации стека TCP/IP виднее. Зато мы сразу получаем управление, не
       * дожидаясь у моря погоды.*/
      char buf[] = "Hello, world!";
      result = send( s, "Hello, world!", 13, 0);
      if( result <= 0 )
      {
              perror( "Error calling send" );
              return 0;
      }
      /* закрываем соединения для посылки данных */
      if( shutdown(s, 1) < 0)
      {
              perror("Error calling shutdown");
              return 0;
      }

      /* читаем ответ сервера */
      fd_set readmask;
      fd_set allreads;
      FD_ZERO( &allreads );
      FD_SET( 0, &allreads );
      FD_SET( s, &allreads );
      for(;;)
      {
              readmask = allreads;
              if( select(s + 1, &readmask, NULL, NULL, NULL ) <= 0 )
              {
                      perror("Error calling select");
                      return 0;
              }
              if( FD_ISSET( s, &readmask ) )
              {
                      char buffer[20];
                      memset(buffer, 0, 20*sizeof(char));
                      int result = recv( s, buffer, sizeof(buffer) - 1, 0 );
                      if( result < 0 )
                      {
                              perror("Error calling recv");
                              return 0;
                      }
                      if( result == 0 )
                      {
                              perror("Server disconnected");
                              return 0;
                      }
                      if(strncmp(buffer, "Hi, dear!", 9) == 0)
                              printf("Got answer. Success.\n");
                      else
                              perror("Wrong answer!");
              }
              if( FD_ISSET( 0, &readmask ) )
              {
                      printf( "No server response" );
                      return 0;
              }
      }
      return 0;
}

void alarm_hndlr( int sig )
{
      return;
}

int main( int argc, char **argv )
{
      // ...
      signal( SIGALRM, alarm_hndlr );
      alarm( 5 );
      int rc = connect( s, (struct sockaddr * )&peer, sizeof( peer ) );
      alarm( 0 );
      if( rc < 0 )
      {
              if( errno == EINTR )
                      error( 1, 0, "Timeout\n" );
      // ...
}

int main( int argc, char **argv )
{
      struct sockaddr_in peer;
      INIT() //
      set_address( argv[1], argv[2], &peer, "tcp" );
      SOCKET s = socket( AAF_INET, SOCK_STREAM, 0 );
      if( !isvalidsock( s ) )
              error( 1, errno, "Socket colling error" );

      /* Добавляет флаг "не блокирующий" к флагам сокета (как дескриптора файла)*/
      int flags = fcntl( s, F_GETFL, 0 ) );
      if( flags < 0 )
              error( 1, errno, "Error calling fcntl(F_GETFL)" );
      if( fcntl( s, F_SETFL, flags | O_NONBLOCK ) < 0 )
              error( 1, errno, "Error calling fcntl(F_SETFL)" );

      int rc = connect( s, (struct sockaddr * )&peer, sizeof( peer ) );
      if( rc < 0 && errno != EINPROGRESS )
              error( 1, errno, "Error calling connect" );

      if( rc == 0 ) // вдруг уже не надо ждать
      {
              if( fcntl( s, F_SETFL, flags ) < 0 )
                      error( 1, errno, "Error calling fcntl (flags recovery)");
              client( s, &peer );
              return 0;
      }

      /* Если ждать надо, ждем с помощью select'а*/
      fd_set rdevents;
      fd_set wrevents;
      fs_set exevents;
      FD_ZERO( &rdevents );
      FD_SET( s, &rdevents );
      wrevents = rdevents;
      exevents = rdevents;
      struct timeval tv;
      tv.tv_sec = 5;
      tv.tv_usec = 0;
      rc = select( s + 1, &rdevents, &wrevents, &exevents, &tv );
      if( rc < 0 )
              error( 1, errno, "Error calling select" );
      else if( rc == 0 )
              error( 1, 0, "Connection timeout" );
      else if( isconnected( s, &rdevents, &wrevents, &exevents ) )
      {
              if( fcntl( s, F_SETFL, flags ) < 0 )
                      error( 1, errno, "Error calling fcntl (flags recovery)" )
              client( s, &peer );
      }
      else
              error( 1, errno, "Error calling connect" );
      return 0;
}

/* В UNIX и WINDOWS разные методы уведомления об успешной попытке соединения, поэтому проверка
вынесена в отдельную функцию.*/

// UNIX
int isconnected( SOCKET s, fd_set *rd, fd_set *wr, fd_set *ex)
{
      int err;
      int len = sizeof( err );
      errno = 0; /*предполагаем, что ошибки нет*/
      if( !FD_ISSET( s, rd ), !FD_ISSET( s, wr ) )
              return 0;
      if( getsockopt( s, SOL_SOCKET, SO_ERROR, &err, &len ) < 0 )
              return 0;
      errno = err; /* если мы не соединились */
      return err == 0;
}

// Windows
int isconnected( SOCKET s, fd_set *rd, fd_set *wr, fd_set *ex)
{
      WSASetLastError( 0 );
      if( !FD_ISSET( s, rd ) && !FD_ISSET( s, wr ) )
              return 0;
      if( !FD_ISSET( s, ex ) )
              return 0;
      return 1;
}