Клиент-серверное приложение. Одновременный запрос клиентов

void TcpThread( void *);
//--------------------------------------------------------------------------
//структура для передачи данных в нить клиента
struct net_info
{
    SOCKET socket_client;
    char* this_client_ip;
};
 
//---------------------------------------------------------------------------
#define MAX_ARRY 100
//Единичная нить работы с клиентом
void ClientThread( void *arg )
{
    SOCKET sock;
    net_info *ni;
    char* this_client_ip;
 
    char buf[MAX_ARRY] = "", buf_in[MAX_ARRY] = "", buf_out[MAX_ARRY] = "";
    int len_recv = 0, cnt=0, ret_code;
 
    fd_set rfd;
    struct timeval tv;
 
    ni = (net_info*)arg;
    this_client_ip = ni->this_client_ip;
    sock = ni->socket_client;
 
//if( ( am.flag ) 
 
        while( len_recv != -1 )
        {
            //Приготовления select()
            FD_ZERO (&rfd);
            FD_SET (sock, &rfd );
            tv.tv_sec = 5;         //5 сек макс ожидание приема
            tv.tv_usec = 0;
 
            ret_code = select( 1+sock, &rfd, 0, 0, &tv);       //Ждем прием
 
            if( ret_code == 0 )
            {
 
                AddErrorToLogFile(h_errno, "%s%s%s",  "Client: Ошибка ожидания сообщения от клиента: ", this_client_ip,  ". select() Error: ");
                break;
            }
            else
            {
                AddExtraStringToLogFile("%s%s%s\n", "Client: Ожидание сообщения от клиента: ", this_client_ip,  ". select() OK" );
            }
 
            len_recv = recv( sock, buf, MAX_ARRY, 0 );       //Получить сообщение
 
            if( len_recv == -1 )
            {
                AddErrorToLogFile(h_errno, "%s%s%s",  "Client: Ошибка получения сообщения от клиента: ", this_client_ip,  ". recv() Error: " );
                break;
            }
            else
            {
                 AddExtraStringToLogFile("%s%s%s%s\n", "Client: Сообщение от клиента: ", this_client_ip,  " получено успешно. recv() OK. Полученное сообщение: ", buf );
                 if( (cnt+len_recv) < MAX_ARRY )
                 {
                    strncpy( &buf_in[cnt], buf, len_recv );
                    cnt+=len_recv;
                 }
                 else
                 {                  
                    break;
                 }
            }
 
            //ответ для клиента
            if( strcmpi( buf_in, "ask" ) == 0 )
            {               
                send( sock, (char *)&am, sizeof(am), 0 );
                AddExtraStringToLogFile("%s%s%s\n", "Client: Сообщение клиенту: ", this_client_ip,  " отправленно успешно. send() OK. Отправленное сообщение: структура данных для клиета" );
                break;
            }
            //ответы для telnet-а
            else if( ( strcmpi( buf_in, "dvt" ) == 0 ) || ( strcmpi( buf_in, "?" ) == 0 ) )
            {
                 sprintf(buf_out, "Qw = %6.2f\t AS = %04.3f\t Zx = %04.1f\n",  am.Qw, am.AS, am.Zx );
                 send( sock, buf_out, strlen(buf_out), 0 );
                 AddExtraStringToLogFile("%s%s%s%s", "Client: Сообщение клиенту: ", this_client_ip,  " отправленно успешно. send() OK. Отправленное сообщение: ", buf_out );
                 break;
            }
            else if( ( strcmpi( buf_in, "qw" ) == 0 ) )
            {
                 sprintf(buf_out, "%6.2f\n",  am.Qw );
                 send( sock, buf_out, strlen(buf_out), 0 );
                 AddExtraStringToLogFile("%s%s%s%s",  "Client: Сообщение клиенту: ", this_client_ip,  " отправленно успешно. send() OK. Отправленное сообщение: ", buf_out );
                 break;
            }
            else if( ( strcmpi( buf_in, "as" ) == 0 ) )
            {
                 sprintf(buf_out, "%04.3f\n",  am.AS );
                 send( sock, buf_out, strlen(buf_out), 0 );
                 AddExtraStringToLogFile("%s%s%s%s", "Client: Сообщение клиенту: ", this_client_ip,  " отправленно успешно. send() OK. Отправленное сообщение: ", buf_out );
                 break;
            }
            else if( ( strcmpi( buf_in, "zx" ) == 0 ) )
            {
                 sprintf(buf_out, "%04.1f\n",  am.Zx );
                 send( sock, buf_out, strlen(buf_out), 0 );
                 AddExtraStringToLogFile("%s%s%s%s", "Client: Сообщение клиенту: ", this_client_ip,  " отправленно успешно. send() OK. Отправленное сообщение: ", buf_out );
                 break;
            }
        }
 
    closesocket( sock );
 
    //return;
    _endthread();
}
 
//---------------------------------------------------------------------------
//Нить выполнения функций сервера
void TcpThread( void *ptrarg)
{
 while (1)
 {
    WSADATA wsd;
    SOCKET s_server, s_client;
    struct sockaddr_in server_addr, client_addr;
    int ret_code;
    int client_addr_size;
 
    //Зарегистрироваться в библиотеке Windows Socket
    if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)      
    {
        AddMessageToStatusbar( "Tcp: Ошибка регистрации WSAStartup" );
 
        AddErrorToLogFile(h_errno, "%s",  "Tcp: Ошибка регистрации в библиотеке Windows Socket. WSAStartup() Error: " );
 
        Sleep(2000);
        continue;
        //return;
    }
    else
    {
        AddExtraStringToLogFile("%s\n", "Tcp: Регистрации в библиотеке Windows Socket успешна. WSAStartup() OK" );
    }
 
    // Создание TCP-сокета, возвращает дескриптор сокета
    s_server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
    if ( s_server  == INVALID_SOCKET )          //протокол IPv4, тип потоковый сокет, транспортный протокол по умомлчанию
    {
        AddMessageToStatusbar ("Tcp: Ошибка создания TCP-сокета");
 
        AddErrorToLogFile(h_errno, "%s",  "Tcp: Ошибка создания TCP-сокета. socket() Error: " );
 
        WSACleanup();                           // Деиницилизация библиотеки Winsock
        Sleep(2000);
        continue;
        //return;
        //exit(EXIT_FAILURE) ;
    }
    else
    {
        AddStringToLogFile("%s\n", "Tcp: Создание TCP-сокета успешно. socket() OK" );
    }
 
    //bind() //Привязывание сокета к прослушиваемому порту
    memset( &server_addr, 0 , sizeof( struct sockaddr_in ));    // очистить  &server_addr
    server_addr.sin_family = AF_INET;                       // семейство протоколов
    server_addr.sin_port = htons(atoi(SERVER_PORT ));       // порт
    server_addr.sin_addr.s_addr = htonl( INADDR_ANY );      // IP – адрес
 
    ret_code = bind( s_server, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in));
 
    if(ret_code )
    {
        AddMessageToStatusbar( "Tcp: Ошибка привязывания сокета к порту" );
 
        AddErrorToLogFile(h_errno, "%s", "Tcp: Ошибка привязывания сокета к прослушиваемому порту. bind() Error: ");
 
        closesocket(s_server);          // закрываем сокет
        WSACleanup();
        Sleep(2000);
        continue;
        //return;
    }
    else
    {
        AddExtraStringToLogFile("%s\n", "Tcp: Привязывание сокета к прослушиваемому порту успешно. bind() OK" );
    }
 
    // listen() //подготавливание привязываемого сокета к принятию входящих соединений
    ret_code = listen( s_server, 0x100);            
 
    if(ret_code  )
    {
        AddMessageToStatusbar( "Tcp: Ошибка подготовки к принятию входящих соединений" );
 
        AddErrorToLogFile(h_errno, "%s",  "Tcp: Ошибка подготовки привязываемого сокета к принятию входящих соединений. listen() Error: " );
 
        closesocket( s_server );
        WSACleanup();
        Sleep(2000);
        continue;
        //return;
    }
    else
    {
        AddExtraStringToLogFile("%s\n", "Tcp: Подготовка привязываемого сокета к принятию входящих соединений успешна. listen() OK" );
    }
 
    //цикл извлечения запросов на подключение из очереди
    client_addr_size=sizeof(client_addr);
 
    while(1)
    {
         s_client = accept( s_server, (struct sockaddr *)&client_addr, &client_addr_size);
 
         char string_temp[200] = "";
 
         client_ip =  inet_ntoa(client_addr.sin_addr);
          
         if(s_client == -1 )
         {
            AddMessageToStatusbar( "Tcp: Ошибка входящего соединения" );
 
            AddErrorToLogFile(h_errno, "%s%s%s",  "Tcp: Ошибка входящего соединения от клиента: ", client_ip, ". accept() Error: " );
 
            closesocket( s_server );
            WSACleanup();
            return;
         }
         else
         {
            AddExtraStringToLogFile("%s%s%s\n", "Tcp: Входящеее соединение от клиента: ", client_ip, " успешно. accept() OK");
         }
 
         //заполнение структуры данных для отправки в нить клиента
         net_info ni;
         ni.socket_client = s_client;
         ni.this_client_ip = client_ip;
 
        
        //время запроса от клиента
        SYSTEMTIME st;
        GetLocalTime(&st);
        sprintf( client_time, "%02d:%02d:%02d", st.wHour,
                                                st.wMinute,
                                                st.wSecond);
                                              //.%03d"       st.wMilliseconds  );
         //заполнение массива информацией о подключенных клиентах
        for (int j=0; j < clients_name_values; j++)
        {
            //если ip адрес есть в списке клиентов
            if ( strcmpi(client_ip_arr[j], client_ip ) == 0 )
            {
                clients_count_connect[j]++;
                strcpy(client_time_arr[j], client_time);
 
                if ( strcmpi (client_name_arr[j], "Unknown") == 0 )
                {
                    sprintf(string_temp, "%s%s", "Клиент: ", client_ip_arr[j]);
                }
                else
                {
                    sprintf(string_temp, "%s%s", "Клиент: ", client_name_arr[j]);
                }
 
                AddMessageToStatusbar( string_temp );
                
                break;
            }
            else
            {
                //если ip адрес нет в списке клиентов
                if ( (  j == clients_name_values - 1 ) && clients_name_values < MAX_CLIENTS)
                {   
                    strcpy(client_time_arr[clients_name_values], client_time);
                    strcpy(client_name_arr[clients_name_values], "Unknown"); //hst->h_name); //"Unknown");
                    strcpy(client_ip_arr[clients_name_values], client_ip);
                    clients_count_connect[clients_name_values]++;
 
                    sprintf(string_temp, "%s%s", "Клиент: ", client_ip_arr[clients_name_values]);
 
                    AddMessageToStatusbar( string_temp );
 
                    clients_name_values ++;
                    break;
                }
            }
        }
        
        //если нет списка клиентов
        if ( clients_name_values == 0 )
        {
            strcpy(client_time_arr[0], client_time);
            strcpy(client_name_arr[0], "Unknown"); //hst->h_name); //"Unknown");
            strcpy(client_ip_arr[0], client_ip);
            clients_count_connect[0]++;
 
            sprintf(string_temp, "%s%s", "Клиент: ", client_ip_arr[0]);
 
            AddMessageToStatusbar( string_temp );
 
            clients_name_values ++;
        }
 
        //Запустить нить работы с единичным клиентом
        _beginthread( ClientThread, 0 , &ni );//&s_client );
 
 
    }
  }
}

#define T_1_2_TCP       "m_1_2_tcp"
#define IP_ADDRESS      "192.168.0.180"
#define TCP_PORT        "1024"
#define REQUEST_TIME    1
 
#define QW              data_out->sof[0].code
#define AS              data_out->sof[1].code
#define ZX              data_out->sof[2].code
#define 1_STATUS        data_out->sof[3].code
#define 2_STATUS        data_out->sof[4].code
 
struct data_float *data_out;
int size_out;
 
static char *flag_name = { T_1_2_TCP };
static char *flag_ip_address = { IP_ADDRESS  };
char *flag_ip_port = TCP_PORT;
 
short flag_debug = ON;
 
int my_receiver , my_params;
 
fd_set rfd;
struct timeval tv;
 
//массив имен параметров
const char *name_par_out[]=
    {
            "Qw",
            "AS",
            "Zx",
            NULL
    };
 
//структура ответа с сервера
 struct ask_measurer {
                        float Qw;
                        float As;
                        float Zx;
                        bool flag_1_status;
                        bool flag_2_status;
                        //short crc;
                    };
 
struct ask_measurer am;
 
int main(int argc, char *argv[]) {
 
    int sockfd;
    struct sockaddr_in serv_addr;
    struct hostent *server;
    int optional;
 
    int ret_code = 0;
    
    /* Анализ командной строки */
    while( ( optional = getopt( argc, argv, "dI:p:" ) ) != -1 )
    {
        switch(optional)
        {
            case 'd':
                flag_debug = ON;
                break;
            case 'I':
                flag_ip_address = optarg;
                break;
            case 'p':
                flag_ip_port = optarg;
                break;
        }
    }
 
    //Найти my_params
    if ((my_params = name_open( T_MY_PARAMS, NAME_FLAG_ATTACH_GLOBAL))== -1 )//id my_params
    if ((my_params = name_open( T_MY_PARAMS, 0))== -1 )
    {
        printf( "%s: No name_locate my_params\n",flag_name);
        exit(EXIT_FAILURE);
    }
 
    //Найти my_receiver
    if ((my_receiver = name_open(T_MY_RECEIVER, NAME_FLAG_ATTACH_GLOBAL )) == -1)
    if ((my_receiver = name_open(T_MY_RECEIVER, 0 )) == -1)
    {
        printf("%s: No receiver name_open()\n",flag_name);
        exit(EXIT_FAILURE);
    }
 
 
    PmPrepSendValues( my_params, name_par_out, &data_out, &size_out );// Подготовить массив нa отправку знaчений пaрaметров в receiver
 
    for(;;)
    {   
 
         // Создание TCP-сокета
        sockfd = socket(AF_INET, SOCK_STREAM, 0);//протокол IPv4, тип потоковый сокет, транспортный протокол по умолчанию
        if (sockfd < 0)
        {
            perror("ERROR opening socket");
            //exit(1);
            //return(-1);
            continue;
        }
    
        server = gethostbyname(flag_ip_address);
        if (server == NULL) {
            fprintf(stderr,"ERROR, no such host\n");
            //exit(0);
            continue;
        }
    
        bzero((char *) &serv_addr, sizeof(serv_addr));//очистить
        serv_addr.sin_family = AF_INET; //Семейство адресов
        bcopy((char *)server->h_addr,
                (char *)&serv_addr.sin_addr.s_addr,
                server->h_length); // IP – адрес
        serv_addr.sin_port = htons(atoi(flag_ip_port)); // порт
    
        /* Now connect to the server */
        if (connect(sockfd,(const struct sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
        {
            if( flag_debug == ON )
            {
                printf("m_1_2_tcp: recv() Error %d\n");
            }
            //exit(1);
            continue;
        }
        //else if( flag_debug == ON )
            //printf("tcp: recv() OK %d\n");
    
        if ( ret_code == -1)
        {
            printf("ERROR opening socket %d\n");
            //exit(1);
            continue;
        }
 
        //посылаем запрос
        ret_code = send( sockfd, "ask", 20, 0 );
    
        if ( ret_code == -1)
        {
            printf("m_1_2_tcp: send ERROR %d\n");
            //exit(1);
            continue;
        }
        //else if( flag_debug == ON )
                //printf("tcp: Send OK %d\n");
    
        //Приготовления select()
        FD_ZERO( &rfd );
        FD_SET( sockfd, &rfd ); //добавить файловый дескриптор sockfd в rfd
    
        tv.tv_sec = 5;          // Set a 5 second timeout.
        tv.tv_usec = 0;
    
        ret_code = select( 1 + sockfd, &rfd, 0, 0, &tv );
    
        if(ret_code <= 0 )
        {
            if( flag_debug == ON )
            {
                printf("m_1_2_tcp: No receive() message from server in 5 sec\n" );
            }
            close(sockfd);
            //exit(1);
            continue;
        }
    
        //memset(buf, 0, MAX_BUF );
    
        //Чтение данных
        ret_code = recv( sockfd, &am, sizeof(am) , 0 );
    
    
        if ( ret_code == -1 )
    
        {   
            if( flag_debug == ON )
            {
                printf("m_1_2_tcp: recv() Error %d\n");
            }
            close(sockfd);
            //exit(1);
            continue;
        }
        else
        {
                QW = am.Qw;
                AS = am.As;
                ZX = am.Zx;
            
 
            //Отправить в receiver
            PmSendValues( my_receiver, data_out, size_out );//// Выполнить отправку знaчений пaрaметров из receiver           
            
            delay(REQUEST_TIME);
        }
        
        close(sockfd);      
    }
 
    return EXIT_SUCCESS;
}