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

#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>
 
int main()
{
    int err=-1;
    int server_sockfd, client_sockfd;
    int server_len, client_len;
    struct sockaddr_in server_address;
    struct sockaddr_in client_address;
 
    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
    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);
    err=(bind(server_sockfd, (struct sockaddr *) &server_address, server_len));
 
    if(err!=0) printf("bind error!\n");
    else printf("bind is ok\n");
    err=-1;
    
    err=(listen(server_sockfd, 5));
    if(err!=0) printf("listen error!\n");
    else printf("listen is ok\n");
    while(1)
    {
        char ch;
 
        printf("server waiting\n");
 
        client_len = sizeof(client_address);
        client_sockfd = accept(server_sockfd, (struct sockaddr *) &client_address, &client_len);
 
        read(client_sockfd, &ch, 1);
        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>
 
void server();
 
struct letter
{
    int len;
    char *data;
}let;
 
 
int main()
{
    server();
}
/*процедура сервера*/
void server()
{
    int err=-1;
    int server_sockfd, client_sockfd;
    int server_len, client_len;
    struct sockaddr_in server_address;
    struct sockaddr_in client_address;
    
    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
    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);
 
    err=(bind(server_sockfd, (struct sockaddr *) &server_address, server_len));
 
    if(err!=0) printf("bind error!\n");
    else printf("bind is ok\n");
    err=-1;
    
    err=(listen(server_sockfd, 5));
    if(err!=0) printf("listen error!\n");
    else printf("listen is ok\n");
    while(1)
    {
        char *ch;
        int len=0;
 
        printf("server waiting\n");
 
        client_len = sizeof(client_address);
        client_sockfd = accept(server_sockfd, (struct sockaddr *) &client_address, &client_len);
 
        read(client_sockfd, &len, 1);
        let.len=len;/*заносим в структуру длинну сообщения*/
 
        ch = calloc (len, sizeof(char));
        let.data = calloc (len, sizeof(char));/*динамически выделяем памят под входящие данные*/
        
        if(!ch) printf("memory error ch\n");
        if(!let.data) printf("memory error data\n");/*проверяем - выделилась ли память*/
        
        read(client_sockfd, &ch, len); /*считываем данные в массив*/
        strncpy(let.data,ch,len);
 
        /*что то тут с ними делаем и отправляем обратно*/
 
        strncpy(ch,let.data,len);
 
        write(client_sockfd, &ch, len);
        close(client_sockfd);
    }
}

--- main.c  2009-12-09 17:31:50.167303824 +0300
+++ main.c  2009-12-09 17:33:06.346302044 +0300
@@ -1,17 +1,20 @@
#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 <unistd.h>
 #include <string.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/types.h>
+#include <sys/socket.h>
 #include <sys/time.h>
-#include <algorithm>
+
+#define max(x,y) (((x) > (y)) ? (x) : (y))
+
 //*******************************************
-#define SERVER_PORT             12002   //порт подключения к серверу
-#define CLIENT_SERVER_1_PORT    12003   //порт подключений  к первому клиент серверу
-#define CLIENT_SERVER_2_PORT    12004   //порт подключений  ко второму клиент серверу
+#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  - вывод измерений скорости через каждые (указанно) мс
 
@@ -112,8 +115,8 @@
     stSockAddr.sin_port = htons(SERVER_PORT);
     stSockAddr.sin_addr.s_addr = INADDR_ANY;
 
-    //
-    if (bind(socketlisten, (const sockaddr*) & stSockAddr, sizeof (stSockAddr)) < 0) {
+
+    if (bind(socketlisten, (struct sockaddr *) & stSockAddr, sizeof (stSockAddr)) < 0) {
         printf("Server: Error bind\n");
         return -1;
     } else
@@ -169,7 +172,7 @@
         fd_set set_sockets_write; //множество сокетов для чтения
         FD_SET(acceptedsockets[0], &set_sockets_write); // положить 1-й сокет в множесвто
 
-        int iSocketN = std::max(acceptedsockets[0], acceptedsockets[1]) + 1; // особо не обращать внимания - переменная служит для
+        int iSocketN = max(acceptedsockets[0], acceptedsockets[1]) + 1; // особо не обращать внимания - переменная служит для
         //получения значение большего из 2-х дескрипторов +1
         //такой параметр просто нужно указывать для  корректной работы выборки select()
 
@@ -186,12 +189,11 @@
         if (selectresult == -1) {
             printf(" Server: error select\n");
             return -1;
-        }
-        else if (selectresult > 0) {
+        } else if (selectresult > 0) {
             //  проверка двух наших сокетов на кторых висят клиенты на чтение (по очереди конечно)
             //  и соответственно чтение с них
-
-            for (size_t i = 0; i < 2; i++) {
+            size_t i;
+            for (i = 0; i < 2; i++) {
                 if (FD_ISSET(acceptedsockets[i], &set_sockets_read))// fd - проверка флага - готов сокет к чтению?
                     //select выставил в множестве напротив каждого сокетов флаг "готов" или "не готов".
                     //эта операция извлекает этот флаг для конкретного сокета
@@ -270,7 +272,7 @@
     }
 
 
-    if (connect(connected_socket, (const sockaddr *) & stSockAddr_Client, sizeof (stSockAddr_Client)) < 0) {
+    if (connect(connected_socket, (struct sockaddr *) & stSockAddr_Client, sizeof (stSockAddr_Client)) < 0) {
         printf("ClientServer: Error connection to server\n");
         close(connected_socket);
         return -1;
@@ -292,7 +294,7 @@
     }
 
 
-    if (bind(socketlisten, (const sockaddr*) & stSockAddr_Server, sizeof (stSockAddr_Server)) < 0) {
+    if (bind(socketlisten, (struct sockaddr*) & stSockAddr_Server, sizeof (stSockAddr_Server)) < 0) {
         printf("ClientServer: Error bind\n");
         return -1;
     } else
@@ -321,7 +323,7 @@
         fd_set set_sockets_write; //множество сокетов
         FD_SET(connected_socket, &set_sockets_write); // положить 1-й сокет в множесвто
 
-        int iSocketN = std::max(connected_socket, accepted_socket) + 1;
+        int iSocketN = max(connected_socket, accepted_socket) + 1;
 
         struct timeval timeout;
         timeout.tv_sec = 0;
@@ -331,8 +333,7 @@
         if (selectresult == -1) {
             printf("ClientServer: error select\n");
             return -1;
-        }
-        else if (selectresult > 0) {
+        } else if (selectresult > 0) {
             //  проверка на запись и запись - тут конструкции аналогичны тем что были в главном сервере
             // мы только ставим другой порт тут и цепляем не 2 клиентов а одного.
 
@@ -396,7 +397,7 @@
     }
 
     // этот клиент -сервер является клиентами к первому клиент серверу и к прост осерверу - создаем 2 соединения:
-    if (connect(sockets_connect[0], (const sockaddr *) & stSockAddr_Client_to_Server, sizeof (stSockAddr_Client_to_Server)) < 0) {
+    if (connect(sockets_connect[0], (struct sockaddr *) & stSockAddr_Client_to_Server, sizeof (stSockAddr_Client_to_Server)) < 0) {
         printf("ClientServer2: Error connection first\n");
         close(sockets_connect[0]);
         return -1;
@@ -416,7 +417,7 @@
     }
 
 
-    if (connect(sockets_connect[1], (const sockaddr *) & stSockAddr_Client_to_ClientServer, sizeof (stSockAddr_Client_to_ClientServer)) < 0) {
+    if (connect(sockets_connect[1], (struct sockaddr *) & stSockAddr_Client_to_ClientServer, sizeof (stSockAddr_Client_to_ClientServer)) < 0) {
         printf("ClientServer2: Error connection second\n");
         close(sockets_connect[1]);
         return -1;
@@ -438,7 +439,7 @@
     }
 
 
-    if (bind(socketlisten, (const sockaddr*) & stSockAddr_Server, sizeof (stSockAddr_Server)) < 0) {
+    if (bind(socketlisten, (struct sockaddr*) & stSockAddr_Server, sizeof (stSockAddr_Server)) < 0) {
         printf("ClientServer2: Error bind\n");
         return -1;
     } else
@@ -470,8 +471,8 @@
         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;
+        int iSocketN = max(sockets_connect[0], sockets_connect[1]);
+        iSocketN = max(iSocketN, acceptedsocket) + 1;
 
         struct timeval timeout;
         timeout.tv_sec = 0;
@@ -481,11 +482,10 @@
         if (selectresult == -1) {
             printf("ClientServer2: error select\n");
             return -1;
-        }
-        else if (selectresult > 0) {
+        } else if (selectresult > 0) {
             //  проверка на чтение и чтение
-
-            for (size_t i = 0; i < 2; i++) {
+            size_t i;
+            for (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);
@@ -555,7 +555,7 @@
     //inet_aton("127.0.0.1", &stSockAddr.sin_addr);
     //в нашем случае мы везде вешаем адресс - макросом INADDR_ANY, т.е. срвер принимает все входящие адреса по заданному порту
 
-    if (connect(connected_socket, (const sockaddr *) & stSockAddr, sizeof (stSockAddr)) < 0) {
+    if (connect(connected_socket, (struct sockaddr *) & stSockAddr, sizeof (stSockAddr)) < 0) {
         printf("Client: Error connection\n");
         close(connected_socket);
         return -1;
@@ -593,8 +593,7 @@
         if (selectresult == -1) {
             printf("Client: error select\n");
             return -1;
-        }
-        else if (selectresult > 0) {
+       } else if (selectresult > 0) {
 
             char buffer[BUFFER_SIZE];
             int bytewritten = write(connected_socket, buffer, BUFFER_SIZE);

printf("Client send speed: %f  kB/s \n", ((double)totalbytes / time_interval * 1000 / 1024));

 pid = fork();
    if (pid == 0)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
 
#define max(x,y) (((x) > (y)) ? (x) : (y))
 
//*******************************************
 
enum {
    BUFFER_SIZE = 4096,
    SPEED_UPDATE_TIME = 5000, //ms  - вывод измерений скорости через каждые (мс)
 
    SERVER_PORT = 12002, //порт подключения к серверу
    CLIENT_SERVER_1_PORT, //порт подключений  к первому клиент серверу
    CLIENT_SERVER_2_PORT, //порт подключений  ко второму клиент серверу
};
 
const char *SRV_1_MSG = "Server read client-server speed: %lf  kB/s \n";
const char *SRV_2_MSG = "Server read client-server2 speed: %lf  kB/s \n";
 
//*********************************************
//порождаемые функции
time_t millisec(void);
int Server(void);
int ClientServer(void);
int ClientServer2(void);
int Client(void);
//********************************************
 
time_t millisec(void) {
 
    time_t ret;
    struct timeval tv;
    
    gettimeofday(&tv, NULL);
 
    ret = (tv.tv_sec * 1000 + tv.tv_usec / 1000);
 
    return ret;
}
//********************************************
//создание нового процесса с обработкой ошибок
 
pid_t makeproc(void) {
 
    pid_t pid = fork();
 
    if ( pid < 0) {
        printf("fork faled\n");
        exit(1);
    }
  return pid;
}
 
//***********************************************
 
int main() {
    //инициализируем создание процесса
    //руководствуемся принципом - каждый клиент к оменту своего рождения уже должен иметь сервер
 
    pid_t pid;
 
    //  server 1
    errno = 0;
    pid = fork();
    if (pid > 0 && errno == 0) {
        printf("I'm child pid = %d\n", pid);
        Server();
    }
    else if (pid < 0) {
        printf("Main: error fork - server\n");
        return (-errno);
    }
 
    //  server-client 2
    sleep(1);
 
    errno = 0;
    pid = fork();
    if (pid > 0 && errno == 0) {
        printf("I'm child 2 pid = %d\n", pid);
        ClientServer();
    }
    else if (pid < 0) {
        printf("Main: error fork - Client Server 1\n");
        return (-errno);
    }
    //  server-client 3
    
    sleep(1);
 
    pid = fork();
    if (pid > 0 && errno == 0) {
        printf("I'm child 3 pid = %d\n", pid);
        ClientServer2();
    }
    else if (pid < 0) {
        printf("Main: error fork - Client Server\n");
        return -(errno);
    }
 
    //  client 3
 
    sleep(1);
    Client();
return 0;
}
 
 
//********************************************
//main server процесс - чистый сервер сервер
 
int Server(void) {
 
    int socketlisten;
    time_t start_time;
    time_t time_interval;
 
    int acceptedsockets[2] = {-1, -1};
 
    /* мини - массив в который складируем
     * количество информации полученной от клиентов
     */
    long long totalbytes[2] = {-1, -1};
 
    struct sockaddr_in stSockAddr;
    memset((void *)&stSockAddr, 0, sizeof(struct sockaddr_in));
 
    printf("Server: starting\n");
 
    //создаем сокет на прослушку соединений
 
    socketlisten = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketlisten < 0) {
        printf("Server: error socket\n");
        return -1;
    } 
    stSockAddr.sin_family = PF_INET;
    stSockAddr.sin_port = htons(SERVER_PORT);
    stSockAddr.sin_addr.s_addr = INADDR_ANY;
 
    if (bind(socketlisten, (struct 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");
 
    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");
 
    start_time = millisec(); // counter эквивалентно у нас типу long long - нафига я так ввел - не помню
 
    while (1) {
        //  счетчик скоростей считывания данных с клиентов
 
        time_interval = millisec() - start_time; //увеличиваем временной интервал пока он не станет у нас больше или равен заданному
        if (time_interval >= SPEED_UPDATE_TIME)//как только - так измеряем количество считанных за него кБайт и выводим
        {
            printf(SRV_1_MSG, ((double) totalbytes[0] / time_interval * 1000 / 1024));
            printf(SRV_2_MSG, ((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 = 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) {
            //  проверка двух наших сокетов на кторых висят клиенты на чтение (по очереди конечно)
            //  и соответственно чтение с них
            size_t i;
            for (i = 0; i < 2; i++) {
                if (FD_ISSET(acceptedsockets[i], &set_sockets_read))// fd - проверка флага - готов сокет к чтению?
                    //select выставил в множестве напротив каждого сокетов флаг "готов" или "не готов".
                    //эта операция извлекает этот флаг для конкретного сокета
                {
                    char buffer[BUFFER_SIZE] = {'\0'};
                    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] = {'\0'};
                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, (struct 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, (struct 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 = 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], (struct 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], (struct 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, (struct 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 = max(sockets_connect[0], sockets_connect[1]);
        iSocketN = 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) {
            //  проверка на чтение и чтение
            size_t i;
            for (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, (struct 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;
    time_t start_time = millisec();
 
    printf("Send Speed:\n");
 
    while (1) {
        //  счетчик сорости - аналогично счетчику всервере - скорость меряем тока на клиенте и сервере
 
        time_t time_interval = millisec() - start_time;
        if (time_interval >= SPEED_UPDATE_TIME) {
            printf("Client send speed: %lf  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);
    shutdown(connected_socket, SHUT_RDWR);
    printf("shutdown. Client.\n");
 
    return 0;
}

pid = fork();
    if (pid  == 0)