Простенький сервер работающий по протоколу 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);
    }
}

#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>
#include <sys/wait.h>
 
#define max(x,y) (((x) > (y)) ? (x) : (y))
#define min(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;
}
 
//***********************************************
 
int main(void) {
    //инициализируем создание процесса
    //руководствуемся принципом - каждый клиент к оменту своего рождения уже должен иметь сервер
    fflush(stdout);
    
// server 1   
    errno = 0;
    pid_t pid = fork();
 
    if ( pid == 0 ) {
        return Server();
    } else if ( pid < 0 ) {
        printf("Main: error fork - server\n");
        return (-errno);
    }
 
    sleep(1);
// server-client 2
    errno = 0;
    pid = fork();
    if ( pid == 0) {
        return ClientServer();
    } else if ( pid < 0 ) {
        printf("Main: error fork - Client Server 1\n");
        return (-errno);
    }
 
    sleep(1);
// server-client 3
    errno = 0;
    pid = fork();
    if ( pid == 0 ) {
         return ClientServer2();
    } else if ( pid < 0 ) {
        printf("Main: error fork - Client Server\n");
        return -(errno);
    }
    sleep(1);  
//  client 3
   return Client();
 
}
 
#define SO_REUSEPORT 15
//********************************************
//main server процесс - чистый сервер сервер
#include <fcntl.h>
 
int Server(void) {
   
    int socketlisten;
    fd_set set_sockets_write; //множество сокетов для чтения
    fd_set set_sockets_read; //множество сокетов для чтения
 
    time_t start_time;
    time_t time_interval;
    int iSocketN;
    int acceptedsockets[2] = {-1, -1};
 
    /* мини - массив в который складируем
     * количество информации полученной от клиентов
     */
    size_t totalbytes[3] = {0,0,0};
    int byteread[2]      = {0};
 
    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, (struct sockaddr*)0, (socklen_t *)0);
    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, (struct sockaddr*)0, (socklen_t *)0);
    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_ZERO(&set_sockets_write);
        FD_SET(acceptedsockets[0], &set_sockets_write); // положить 1-й сокет в множесвто
        FD_SET(acceptedsockets[1], &set_sockets_write); // положить 2-й сокет в множесвто
        
       
        FD_ZERO(&set_sockets_read);
        FD_SET(acceptedsockets[0], &set_sockets_read); // положить 1-й сокет в множесвто
        FD_SET(acceptedsockets[1], &set_sockets_read); // положить 2-й сокет в множесвто
 
        iSocketN = max(acceptedsockets[1], acceptedsockets[0]) + 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'};                   
                    byteread[i] = read(acceptedsockets[i], buffer, BUFFER_SIZE); //берем из буфера данные и считываем в массив "буфер"
                    if (byteread[i] < 0) //а эта переменна - проверка - прочиталось ли - и одновременно соклько прочли
                    {
                        printf("Server: error read\n");
                        return -1;
                    } else if (byteread[i] == 0) //это на случай если клиент по каким то причинам "отвалился"
                    {
                        printf("Server: client is disconnected\n");
 
                        close(acceptedsockets[0]); //закрываем все сокеты сервера
                        close(acceptedsockets[1]);
                        close(socketlisten);
                        //клиент исчез
                        break;
                    }
                    FD_CLR (acceptedsockets[i], &set_sockets_read);
                    totalbytes[i] = totalbytes[i] + byteread[i]; //знаачение тоталбайтс увеличиваем на то сколько байт прочли
                }
            }
 
            //  проверка на запись и сама запись
            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[3] = totalbytes[3] + bytewritten; //знаачение тоталбайтс увеличиваем на то сколько байт записали
            }
        }
    }
 
    close(acceptedsockets[0]);
    close(acceptedsockets[1]);
    close(socketlisten);
 
    printf("shutdown. server.\n");
 
    return 0;
}
 
 
//*********************************************************
//client -  server proc  - первый клиент сервер
 
int ClientServer(void) {
    // -----------------------------------------------------------
    //  создаем клиента
    //  int yes = 1;
    printf("ClientServer: started\n\n");
 
    int connected_socket = -1;
 
    struct sockaddr_in stSockAddr_Client;
 
    memset((void *)&stSockAddr_Client, 0, sizeof(struct sockaddr_in));
 
    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;
    memset((void *)&stSockAddr_Server, 0, sizeof(struct sockaddr_in));
 
    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 = -1;
 
    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_ZERO (&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, (fd_set *)0, &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] = {0};
                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] = {0};
                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] = {0};
 
    struct sockaddr_in stSockAddr_Client_to_Server;
    memset((void *)&stSockAddr_Client_to_Server, 0, sizeof(struct sockaddr_in));
 
    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;
    memset((void *)&stSockAddr_Client_to_ClientServer, 0, sizeof(struct sockaddr_in));
 
    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");
        shutdown(sockets_connect[1], 2);
        close(sockets_connect[1]);
        return -1;
    } else
        printf("ClientServer2: connection secondt to client - server is ok\n");
 
    //----------------------------------------------------------
    //  create server
    struct sockaddr_in stSockAddr_Server;
    memset((void *)&stSockAddr_Server, 0, sizeof(struct sockaddr_in));
 
    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 = -1;
 
    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 set_sockets_write; //множество сокетов
 
        FD_ZERO (&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(sockets_connect[0], &set_sockets_write); // положить 1-й сокет в множесвто
        FD_SET(sockets_connect[1], &set_sockets_write); // положить 2-й сокет в множесвто
    
        int iSocketN = min(sockets_connect[1], sockets_connect[0]) + 1;        
 
        struct timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = 10;
 
        int selectresult = select(iSocketN, &set_sockets_read,
                                            &set_sockets_write,
                                            (fd_set *)0,
                                            &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 buff[BUFFER_SIZE] = {0};
                    int bytewritten = write(sockets_connect[i], buff, 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] = {0};
                    int byteread = recv(sockets_connect[i], buffer, BUFFER_SIZE, MSG_OOB);
                    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] = {0};
                int byterd = read(acceptedsocket, buffer, BUFFER_SIZE);                
                if (byterd < 0) {
                    printf("ClientServer2: error read\n");
                    return -1;
                } else if (byterd == 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;
    memset((void *)&stSockAddr, 0, sizeof(stSockAddr));
 
    stSockAddr.sin_family = PF_INET;
    stSockAddr.sin_port = htons(CLIENT_SERVER_2_PORT);
    stSockAddr.sin_addr.s_addr = INADDR_ANY;
 
    if (connect(connected_socket, (struct sockaddr *)&stSockAddr, sizeof(stSockAddr)) < 0) {
        printf("Client: Error connection\n");
        shutdown(connected_socket, SHUT_RDWR);
        close(connected_socket);
        return -1;
    } else
        printf("Client:  connection to client server 2 is ok\n");
 
    size_t 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_ZERO(&setsocket);
        FD_SET(connected_socket, &setsocket); // положить 1 сокет в множесвто
 
        struct timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = 10;
 
        int selectresult = select(connected_socket + 1, (fd_set *)0, &setsocket, (fd_set *)0, &timeout);
        if (selectresult == -1) {
            printf("Client: error select\n");
            return -1;
        } else if (selectresult > 0) {
 
            char buffer[2*BUFFER_SIZE] = {0};
            memset(buffer, 0xA5, 2*BUFFER_SIZE);
           ssize_t 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 (EXIT_SUCCESS);
}

#define FILE_NAME_LENGTH 8
 
     char *newfile = (char *)malloc(PATH_MAX); /* PATH_MAX не помню */
          
     strncpy(filename, string_from_server, FILE_NAME_LENGTH);
     newfile = dirname(oldfile);
     strncat(newfile, filename, FILE_NAME_LENGTH);
     rename(oldfile, newfile);
 
     // ......
 
    free(newfile);

        while(1)
        {
                char *path = PATH_TO_FILE;
                char buf[MAX_LINE_LEN];
                FILE *file;
                int nread;
                ...
 
                nread = read(client_sockfd, &buf, sizeof(buf) - 1);
                if (nread < 1) {
                        printf("read: %s. closing connection\n", strerror(errno));
                        close(client_sockfd);
                        continue;
                }
                buf[nread] = 0;
                printf("server got: \"%s\"\n", buf);
 
                if (strncmp(buf, "TEST", 4) == 0) {
                        strncpy(buf, "OK\n", sizeof(buf) -1);
                        buf[sizeof(buf) - 1] = 0;
                } else if(strncmp(buf, "GETTEST", 7) == 0) {
                        file = fopen(path, "r");
                        if (file == NULL ||
                            fgets(buf, sizeof(buf), file) == NULL) {
                                strncpy(buf, "ERR\n", sizeof(buf) -1);
                                buf[sizeof(buf) - 1] = 0;
                        }
                        if (file)
                                fclose(file);
                } else {
                        printf("bad command from client, closing connection\n");
                        close(client_sockfd);
                        continue;
                }
 
                printf("server answer: \"%s\"\n", buf);
                write(client_sockfd, &buf, strlen(buf));
                close(client_sockfd);
        }

radist04ka@ gcc -o TempPrg temp.c
temp.c: In function 'main':
temp.c:34: error: 'file' undeclared (first use in this function)
temp.c:34: error: (Each undeclared identifier is reported only once
temp.c:34: error: for each function it appears in.)
temp.c:35: error: 'MAX_LINE_LEN' undeclared (first use in this function)
temp.c:38: error: expected expression before '...' token
temp.c:42: error: 'errno' undeclared (first use in this function)
temp.c:50: warning: incompatible implicit declaration of built-in function 'strncpy'
temp.c:56: warning: incompatible implicit declaration of built-in function 'strncpy'
temp.c:68: warning: incompatible implicit declaration of built-in function 'strlen'

       else printf("listen is ok\n");
        daemon(0,0);
        while(1)
        {

                        file = fopen(path, "r");
                        if (file == NULL ||
                            fgets(buf, sizeof(buf), file) == NULL) {
                                strncpy(buf, "ERR\n", sizeof(buf) -1);
                                buf[sizeof(buf) - 1] = 0;
                        }

daemon(0, 1);

    int fd;
 
    switch (fork()) {
    case -1:
        return (-1);
    case 0:
        break;
    default:
        exit(0);
    }
 
    if (setsid() == -1)
        return (-1);
 
    if (fd = open("/dev/null", O_RDWR, 0)) != -1) {
        (void)dup2(fd, STDIN_FILENO);
        (void)dup2(fd, STDOUT_FILENO);
        (void)dup2(fd, STDERR_FILENO);
        if (fd > 2)
            (void)close(fd);
    }
    return (0);

    if ((fd = open(".", O_RDONLY, 0)) == -1)
        err(1, "open()");
 
    /* Тут делаем chdir() на прямую или что-то еще меняющее текущую папку.*/
 
    if (fchdir(fd) == -1)
          err(1, "fchdir()");