Простенький сервер работающий по протоколу TCP/IP, на основе сокетов

  while(1)
    {
        char *ch;
        char lenbuf[256];
        int len;
 
        printf("server waiting\n");
 
        client_len = sizeof(client_address);
        client_sockfd = accept(server_sockfd, (struct sockaddr *) &client_address, &client_len);
 
        read(client_sockfd, lenbuf, sizeof(lenbuf));
printf("%s\n",lenbuf);
    len = atoi(lenbuf);
printf("%s\n",len);
        let.len = len;
printf("%s\n",let.len);
        ch = calloc (len, sizeof(char));
printf("%s\n",ch);
        let.data = calloc (len, sizeof(char));
printf("%s\n",let.data);
        if(!ch) printf("memory error ch\n");
printf("%s\n",ch);
        if(!let.data) printf("memory error data\n");
printf("%s\n",let.data); 
        read(client_sockfd, ch, len);
printf("%s\n",ch);
        strncpy(let.data, ch, len);
 printf("%s\n",len);
    printf("%s\n",ch);
 printf("%s\n",let.data);
        strncpy(ch, let.data, len);
        write(client_sockfd, ch, len);
        close(client_sockfd);
    }

    while( (nr = read(cli_sock, buf, BUFSIZE)) > 0) {
        printf("client: %s\n", buf);    /* полученная строка */
      buf[nr-2] = '\0';
        printf("client: %s\n", buf);    /* полученная строка */
    printf("client: %d\n", nr);
        if(strcmp(buf, "quit") == 0) break;
        /* далее необходимые преобразование */
    }

[root@myhost ~]# ./serv1
enter data: 
ewq
^C
[root@myhost ~]#

[root@myhost ~]# ./serv 9734
client: (пусто)
client: (пусто)
client: 1
[root@myhost ~]#

        write(sockfd, &let.data, 1);
        read(sockfd, &let.data, 1);

read(client_sockfd, &ch, 1);
printf("%s\n",ch);
 
write(client_sockfd, &ch, 1);

printf("%c\n",ch);

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
int server_sockfd, client_sockfd;
int server_len, client_len;
struct sockaddr_in server_address;
struct sockaddr_in client_address;
 
 
// 2. Open socket for this SERVER
 
unlink("server_socket");
server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
 
// 3. Socket name for SERVER
 
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
server_address.sin_port = htons(9734);
server_len = sizeof(server_address);
bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
 
// 4. Connecting socket for SERVER
 
listen (server_sockfd, 5);
while(1) {
char *ch;
 
printf("server waiting\n");
 
// 5. I/O socket "SOCKFD"
 
client_len = sizeof (client_address);
client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len);
 
read(client_sockfd, &ch, 1);
printf("%c , %d\n",ch,ch);
 
write(client_sockfd, &ch, 1);
close(client_sockfd);
 
 
}
}

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
int sockfd;
int len;
struct sockaddr_in address;
int result;
char ch = '1';
 
 
// 2. Open socket for this SERVER
 
sockfd = socket(AF_INET, SOCK_STREAM, 0);
 
// 3. Socket name for SERVER
 
address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr("127.0.0.1");
address.sin_port = htons(9734);
len = sizeof(address);
 
// 4. Connecting socket for SERVER
 
result = connect (sockfd, (struct sockaddr *)&address, len);
 
if (result == -1) {
perror("oops: client1");
exit(1);
}
// 5. I/O socket "SOCKFD"
 
write (sockfd, &ch, 1);
read (sockfd, &ch, 1);
printf("%c , %d\n",ch,ch);
close(sockfd);
 
}

server waiting
1 , 134513713
server waiting

1 , 49

char *ch = "1";

1 , 134514496

%s а не %с

%s на %с

 , 134513728

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <algorithm>
//*******************************************
#define SERVER_PORT             12002   //порт подключения к серверу
#define CLIENT_SERVER_1_PORT    12003   //порт подключений  к первому клиент серверу
#define CLIENT_SERVER_2_PORT    12004   //порт подключений  ко второму клиент серверу
#define BUFFER_SIZE             4096
#define SPEED_UPDATE_TIME       5000    //ms  - вывод измерений скорости через каждые (указанно) мс
 
//*********************************************
//порождаемые функции
int Server(void);
int ClientServer(void);
int ClientServer2(void);
int Client(void);
//********************************************
typedef long long Counter;
//********************************************
Counter millisec()
{
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}
//********************************************
//создание нового процесса с обработкой ошибок
pid_t makeproc(void)
{
    pid_t pid;
 
    if((pid = fork())<0)
    {
       printf("fork faled\n");
       exit(1);
    }
    else return pid;
}
 
//***********************************************
int main()
{
    //инициализируем создание процесса
    //руководствуемся принципом - каждый клиент к оменту своего рождения уже должен иметь сервер
 
    pid_t pid;
 
    //  server 1
 
    pid = fork();
    if(pid == 0)
        return Server();
    else if(pid < 0)
    {
        printf("Main: error fork - server\n");
        return 1;
    }
 
    //  server-client 2
 
    sleep(1);
 
    pid = fork();
    if(pid == 0)
        return ClientServer();
    else if(pid < 0)
    {
        printf("Main: error fork - Client Server 1\n");
        return 1;
    }
 
    //  server-client 3
 
    sleep(1);
 
    pid = fork();
    if(pid == 0)
        return ClientServer2();
    else if(pid < 0)
    {
        printf("Main: error fork - Client Server\n");
        return 1;
    }
 
    //  client 3
 
    sleep(1);
 
    return Client();
}
 
 
//********************************************
//main server процесс - чистый сервер сервер
 
int Server()
{
    printf("Server: starting\n");
 
    //создаем сокет на прослушку соединений
 
    int socketlisten = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketlisten < 0)
    {
        printf ("Server: error socket\n");
        return -1;
    }
 
   struct sockaddr_in stSockAddr;
 
    stSockAddr.sin_family = PF_INET;
    stSockAddr.sin_port = htons(SERVER_PORT);
    stSockAddr.sin_addr.s_addr = INADDR_ANY;
 
    //
    if (bind (socketlisten, (const sockaddr*)&stSockAddr, sizeof(stSockAddr))<0)
    {
        printf("Server: Error bind\n");
        return -1;
    }
    else
        printf("Server: bind is ok\n");
 
    if (listen (socketlisten ,1 ) < 0)
    {
        printf ("Server:error listen\n");
        return -1;
    }
    else
        printf("Server: listen is ok\n\n");
 
    int acceptedsockets[2];
 
    acceptedsockets[0] = accept (socketlisten, NULL, NULL);
    if (acceptedsockets[0] < 0)
    {
        printf("Server: error  accept first\n");
        return -1;
    }
    else
        printf("Server: accept first is ok\n\n");
 
    acceptedsockets[1] = accept (socketlisten, NULL, NULL);
    if (acceptedsockets[1] < 0)
    {
        printf("Server: error  accept second\n");
        return -1;
    }
    else
        printf("Server: accept second is ok\n\n");
 
 
    long long totalbytes[2] = {0, 0};//мини - массив в который складируем количество информации полученной от клиентов
    Counter start_time = millisec(); // counter эквивалентно у нас типу long long - нафига я так ввел - не помню
 
    while(1)
    {
        //  счетчик скоростей считывания данных с клиентов
 
        Counter time_interval = millisec() - start_time;//увеличиваем временной интервал пока он не станет у нас больше или равен заданному
        if(time_interval >= SPEED_UPDATE_TIME)//как только - так измеряем количество считанных за него кБайт и выводим
        {
            printf("Server read client-server speed: %f  kB/s \n", ((double)totalbytes[0] / time_interval * 1000 / 1024));
            printf("Server read client-server2 speed: %f  kB/s \n", ((double)totalbytes[1] / time_interval * 1000 / 1024));
           
            // как только вывели информацию - счетчики полученных данных занулили
            totalbytes[0] = 0;
            totalbytes[1] = 0;
            
            start_time = millisec();
        }
 
 
        fd_set set_sockets_read; //множество сокетов для чтения
        FD_SET (acceptedsockets[0], &set_sockets_read); // положить 1-й сокет в множесвто
        FD_SET (acceptedsockets[1], &set_sockets_read); // положить 2-й сокет в множесвто
 
        fd_set set_sockets_write; //множество сокетов для чтения
        FD_SET (acceptedsockets[0], &set_sockets_write); // положить 1-й сокет в множесвто
 
        int iSocketN = std::max(acceptedsockets[0], acceptedsockets[1]) + 1;// особо не обращать внимания - переменная служит для 
                                                                            //получения значение большего из 2-х дескрипторов +1  
                                                                            //такой параметр просто нужно указывать для  корректной работы выборки select()
 
        struct timeval timeout;//задаем значение таймаута - тоже для выборки select()- чтоб проверяла буфера передачи сокетов каждые 10 мс
        timeout.tv_sec = 0;
        timeout.tv_usec = 10;
 
        int selectresult = select (iSocketN, &set_sockets_read, &set_sockets_write, NULL, &timeout);
                                                            //тут мы задаем Убунте, которая управляет нашими сокетами, 2 вопроса: 
                                                            //1. а готовы ли сокеты из множества set_sockets_read к тому, 
                                                            //чтобы из них можно было читать (с помощью read)? 
                                                            //2. а готовы ли сокеты из множества set_sockets_write к тому, 
                                                            //чтобы через них можно было отправлять данные (с помощью write)?
        if (selectresult == -1)
        {
            printf (" Server: error select\n");
            return -1;
        }
 
        else if (selectresult > 0 )
        {
            //  проверка двух наших сокетов на кторых висят клиенты на чтение (по очереди конечно) 
            //  и соответственно чтение с них
 
            for(size_t i = 0; i < 2; i++)
            {
                if(FD_ISSET(acceptedsockets[i], &set_sockets_read))// fd - проверка флага - готов сокет к чтению? 
                                                                //select выставил в множестве напротив каждого сокетов флаг "готов" или "не готов". 
                                                                //эта операция извлекает этот флаг для конкретного сокета
                {
                    char buffer[BUFFER_SIZE];
                    int byteread =  read (acceptedsockets[i], buffer, BUFFER_SIZE);//берем из буфера данные и считываем в массив "буфер"
                    if (byteread<0) //а эта переменна - проверка - прочиталось ли - и одновременно соклько прочли
                    {
                        printf ("Server: error read\n");
                        return -1;
                    }
                    else if (byteread == 0) //это на случай если клиент по каким то причинам "отвалился"
                    {
                        printf("Server: client is disconnected\n");
 
                        close(acceptedsockets[0]);//закрываем все сокеты сервера
                        close(acceptedsockets[1]);
                        close(socketlisten);
                         //клиент исчез
                        break ;
                    }
 
                    totalbytes[i] = totalbytes[i] + byteread;//знаачение тоталбайтс увеличиваем на то сколько байт прочли
                }
            }
 
            //  проверка на запись и сама запись 
 
            if(FD_ISSET(acceptedsockets[0], &set_sockets_write)) // fd - проверка флага - готов сокет к записи?
            {
                char buffer[BUFFER_SIZE];
                int bytewritten =  write (acceptedsockets[0], buffer, BUFFER_SIZE);//берем из массив "буфера" данные и записываем в буфер
                if (bytewritten < 0 )//а эта переменна - проверка - записалось ли - и одновременно соклько записали
                {
                    printf ("Server: error write\n");
                    return -1;
                }
 
                totalbytes[2] = totalbytes[2] + bytewritten;//знаачение тоталбайтс увеличиваем на то сколько байт записали
 
            }
 
       
        }
    }
 
    close(acceptedsockets[0]);
    close(acceptedsockets[1]);
    close (socketlisten);
 
    printf("shutdown. server.\n");
 
    return 0;
}
 
 
//*********************************************************
//client -  server proc  - первый клиент сервер
 
 
int ClientServer(void)
{
    // -----------------------------------------------------------
    //  создаем клиента
    printf("ClientServer: started\n\n");
 
    int connected_socket;
 
    struct sockaddr_in stSockAddr_Client;
 
    stSockAddr_Client.sin_family = PF_INET;
    stSockAddr_Client.sin_port = htons(SERVER_PORT); 
    stSockAddr_Client.sin_addr.s_addr = INADDR_ANY;
 
    connected_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (connected_socket < 0)
    {
        printf ("ClientServer: error socket\n");
        return -1;
    }
 
 
    if ( connect (connected_socket, (const sockaddr *)&stSockAddr_Client, sizeof(stSockAddr_Client))<0)
    {
        printf ("ClientServer: Error connection to server\n");
        close (connected_socket);
        return -1;
    }
    else
        printf("ClientServer: connection to server is ok\n");
 
    //----------------------------------------------------------
    //  create server
    struct sockaddr_in stSockAddr_Server;
 
    stSockAddr_Server.sin_family = PF_INET;
    stSockAddr_Server.sin_port = htons(CLIENT_SERVER_1_PORT);
    stSockAddr_Server.sin_addr.s_addr = INADDR_ANY;
 
    int socketlisten = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketlisten < 0)
    {
        printf ("ClientServer: error socket\n");
        return -1;
    }
 
 
    if (bind (socketlisten, (const sockaddr*)&stSockAddr_Server, sizeof(stSockAddr_Server))<0)
    {
        printf("ClientServer: Error bind\n");
        return -1;
    }
    else
        printf("ClientServer: bind is ok\n");
 
    if (listen (socketlisten, 1) < 0)
    {
        printf ("ClientServer: error listen\n");
        return -1;
    }
    else
        printf("ClientServer: listen is ok\n\n");
 
    int accepted_socket;
 
    accepted_socket = accept (socketlisten, NULL, NULL);
    if (accepted_socket < 0)
    {
        printf("ClientServer: error  accept\n");
        return -1;
    }
     else
        printf("ClientServer: accept is ok\n\n");
 
    
    while(1)
    {
        fd_set set_sockets_read; //множество сокетов
        FD_SET (accepted_socket, &set_sockets_read); // положить 1-й сокет в множесвто
 
        fd_set set_sockets_write; //множество сокетов
        FD_SET (connected_socket, &set_sockets_write); // положить 1-й сокет в множесвто
 
        int iSocketN = std::max(connected_socket, accepted_socket) + 1;
 
        struct timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = 10;
 
        int selectresult = select (iSocketN, &set_sockets_read, &set_sockets_write, NULL, &timeout);
        if (selectresult == -1)
        {
            printf ("ClientServer: error select\n");
            return -1;
        }
 
        else if (selectresult > 0 )
        {
            //  проверка на запись и запись - тут конструкции аналогичны тем что были в главном сервере 
                                                // мы только ставим другой порт тут и цепляем не 2 клиентов а одного.
 
            if(FD_ISSET(connected_socket, &set_sockets_write))
            {
                char buffer[BUFFER_SIZE];
                int bytewritten =  write (connected_socket, buffer, BUFFER_SIZE);
                if (bytewritten < 0 )
                {
                    printf ("ClientServer: error write\n");
                    return -1;
                }
            }
 
            //  проверка на чтение и чтение
 
            if(FD_ISSET(accepted_socket, &set_sockets_read))
            {
                char buffer[BUFFER_SIZE];
                int byteread =  read (accepted_socket, buffer, BUFFER_SIZE);
                if (byteread < 0)
                {
                    printf ("ClientServer: error read\n");
                    return -1;
                }
                else if (byteread == 0)
                {
                    printf("ClientServer: client is disconnected\n");
                    //клиент исчез
                    break ;
                }
            }
              
        }
    }
 
    close(connected_socket);
    close(accepted_socket);
    close(socketlisten);
 
    printf("shutdown. ClientServer.\n");
 
    return 0;
}
 
 
//*********************************************************
//client -  server proc-второй клиент сервер
 
 
int ClientServer2()
{
    // -----------------------------------------------------------
    //  create clients
    printf("ClientServer2: starting\n\n");
 
    int sockets_connect[2];
 
    struct sockaddr_in stSockAddr_Client_to_Server;
 
    stSockAddr_Client_to_Server.sin_family = PF_INET;
    stSockAddr_Client_to_Server.sin_port = htons(SERVER_PORT);
    stSockAddr_Client_to_Server.sin_addr.s_addr = INADDR_ANY;
 
    sockets_connect[0] = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockets_connect[0] < 0)
    {
        printf ("ClientServer2: error socket\n");
        return -1;
    }
 
    // этот клиент -сервер является клиентами к первому клиент серверу и к прост осерверу - создаем 2 соединения:
    if ( connect (sockets_connect[0], (const sockaddr *)&stSockAddr_Client_to_Server, sizeof(stSockAddr_Client_to_Server))<0)
    {
        printf ("ClientServer2: Error connection first\n");
        close (sockets_connect[0]);
        return -1;
    }
    else
        printf("ClientServer2: connection first to server is ok\n");
 
    struct sockaddr_in stSockAddr_Client_to_ClientServer;
 
    stSockAddr_Client_to_ClientServer.sin_family = PF_INET;
    stSockAddr_Client_to_ClientServer.sin_port = htons(CLIENT_SERVER_1_PORT);
    stSockAddr_Client_to_ClientServer.sin_addr.s_addr = INADDR_ANY;
 
    sockets_connect[1] = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockets_connect[1] < 0)
    {
        printf ("ClientServer2: error socket\n");
        return -1;
    }
 
 
    if ( connect (sockets_connect[1], (const sockaddr *)&stSockAddr_Client_to_ClientServer, sizeof(stSockAddr_Client_to_ClientServer))<0)
    {
        printf ("ClientServer2: Error connection second\n");
        close (sockets_connect[1]);
        return -1;
    }
    else
        printf("ClientServer2: connection secondt to client - server is ok\n");
 
    //----------------------------------------------------------
    //  create server
    struct sockaddr_in stSockAddr_Server;
 
    stSockAddr_Server.sin_family = PF_INET;
    stSockAddr_Server.sin_port = htons(CLIENT_SERVER_2_PORT);
    stSockAddr_Server.sin_addr.s_addr = INADDR_ANY;
 
    int socketlisten = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketlisten < 0)
    {
        printf ("ClientServer2: error socket\n");
        return -1;
    }
 
 
    if (bind (socketlisten, (const sockaddr*)&stSockAddr_Server, sizeof(stSockAddr_Server))<0)
    {
        printf("ClientServer2: Error bind\n");
        return -1;
    }
    else
        printf("ClientServer2: bind is ok\n");
 
    if (listen (socketlisten ,1 ) < 0)
    {
        printf ("ClientServer2: error listen\n");
        return -1;
    }
    else
        printf("ClientServer2: listen is ok\n\n");
 
    int acceptedsocket;
 
    acceptedsocket = accept (socketlisten, NULL, NULL);
    if (acceptedsocket < 0)
    {
        printf("ClientServer2: error  accept\n");
        return -1;
    }
    else
        printf("ClientServer2: accept is ok\n\n");
 
 
    while(1)
    {
        fd_set set_sockets_read; //множество сокетов
        FD_SET (acceptedsocket, &set_sockets_read); // положить сокет в множесвто
        FD_SET (sockets_connect[0], &set_sockets_read); // положить 1-й сокет в множесвто
        FD_SET (sockets_connect[1], &set_sockets_read); // положить 2-й сокет в множесто
 
        fd_set set_sockets_write; //множество сокетов
        FD_SET (sockets_connect[0], &set_sockets_write); // положить 1-й сокет в множесвто
        FD_SET (sockets_connect[1], &set_sockets_write); // положить 2-й сокет в множесвто
 
        int iSocketN = std::max(sockets_connect[0], sockets_connect[1]);
        iSocketN = std::max(iSocketN, acceptedsocket) + 1;
 
        struct timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = 10;
 
        int selectresult = select (iSocketN, &set_sockets_read, &set_sockets_write, NULL, &timeout);
        if (selectresult == -1)
        {
            printf ("ClientServer2: error select\n");
            return -1;
        }
 
        else if (selectresult > 0 )
        {
            //  проверка на чтение и чтение
 
            for(size_t i = 0; i < 2; i++)
            {
                if(FD_ISSET(sockets_connect[i], &set_sockets_write))
                {
                    char buffer[BUFFER_SIZE];
                    int bytewritten =  write (sockets_connect[i], buffer, BUFFER_SIZE);
                    if (bytewritten < 0 )
                    {
                        printf ("ClientServer2: error write\n");
                        return -1;
                    }
                }
 
                if(FD_ISSET(sockets_connect[i], &set_sockets_read))
                {
                    char buffer[BUFFER_SIZE];
                    int byteread =  read (sockets_connect[i], buffer, BUFFER_SIZE);
                    if (byteread < 0 )
                    {
                        printf ("ClientServer2: error read\n");
                        return -1;
                    }
                    else if (byteread == 0)
                    {
                        printf("ClientServer2: some client is disconnected\n");
                        //клиент исчез
                        break ;
                    }
                }
            }
 
            //  проверка на запись и запись
 
            if(FD_ISSET(acceptedsocket, &set_sockets_read))
            {
                char buffer[BUFFER_SIZE];
                int byteread =  read (acceptedsocket, buffer, BUFFER_SIZE);
                if (byteread < 0)
                {
                    printf ("ClientServer2: error read\n");
                    return -1;
                }
                else if (byteread == 0)
                {
                    printf("ClientServer2: client is disconnected\n");
                    //клиент исчез
                    break ;
                }
            }
                }
    }
 
    close(sockets_connect[0]);
    close(sockets_connect[1]);
    close(acceptedsocket);
    close(socketlisten);
 
    printf("shutdown. ClientServer2.\n");
 
    return 0;
}
 
 
int Client()//наш клиент - в чистом виде
{
    printf("Client: starting\n\n");
    int connected_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 
    if (connected_socket < 0)
    {
        printf ("Client: error parent socket\n");
        return -1;
    }
 
    struct sockaddr_in stSockAddr;
 
    stSockAddr.sin_family = PF_INET;
    stSockAddr.sin_port = htons(CLIENT_SERVER_2_PORT);
    stSockAddr.sin_addr.s_addr = INADDR_ANY;
    //  NOTE: последняя стрчока с объявлением  IP адреса еще может быть записанна в такой манере:
    //inet_aton("127.0.0.1", &stSockAddr.sin_addr);
    //в нашем случае мы везде вешаем адресс - макросом INADDR_ANY, т.е. срвер принимает все входящие адреса по заданному порту
 
    if ( connect (connected_socket, (const sockaddr *)&stSockAddr, sizeof(stSockAddr))<0)
    {
        printf ("Client: Error connection\n");
        close (connected_socket);
        return -1;
    }
    else
        printf("Client:  connection to client server 2 is ok\n");
 
 
    long long totalbytes = 0;
    Counter start_time = millisec();
 
    printf("Send Speed:\n");
 
    while(1)
    {
        //  счетчик сорости - аналогично счетчику всервере - скорость меряем тока на клиенте и сервере
 
        Counter time_interval = millisec() - start_time;
        if(time_interval >= SPEED_UPDATE_TIME)
        {
            printf("Client send speed: %f  kB/s \n", ((double)totalbytes / time_interval * 1000 / 1024));
 
            //  ...
            totalbytes = 0;
            start_time = millisec();
        }
 
        //  посыл
 
        fd_set setsocket; //множество сокетов
        FD_SET (connected_socket, &setsocket); // положить 1 сокет в множесвто
 
        struct timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = 10;
 
        int selectresult = select (connected_socket + 1, NULL, &setsocket, NULL, &timeout);
        if (selectresult == -1)
        {
            printf ("Client: error select\n");
            return -1;
        }
 
        else if (selectresult > 0 )
        {
            
            char buffer[BUFFER_SIZE];
            int bytewritten =  write (connected_socket, buffer, BUFFER_SIZE);
            if (bytewritten < 0 )
            {
                printf ("Client: error write\n");
                return -1;
            }
 
            totalbytes = totalbytes + bytewritten;
 
        }
    }
 
    close (connected_socket);
    printf("shutdown. Client.\n");
 
    return 0;
}

typedef u8 unsigned short;
 
for (size_t i = 0; i < 2; i++) {
for (u8 i = 0; i < 2; i++) {