imit.cpp - master - memset/doc

imit.cpp
527 строк19 KB
memset
Create: imit.cpp
06 июн 2026, 16:30
06 июн 2026, 16:30f7bcab7
/**
@mainpage
@author Петрова М.С. (memset)
@version 1.0
@date 2022
@note Имитатор клиента UDP для ****
1. Считывает 6 файлов с данными для каждого формуляра ()
2. Cортирует вычетанные данные по времени
3. Заполняет формуляр данными, выдает созданные формуляры с временными задержками,
                                        равными временной разнице м/д формулярами
4. Завершает работу
*/
#include <netinet/in.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>

#include <netdb.h>

#include <iostream>
#include <fstream>
#include <sstream>

#include <vector>
#include <string>
#include <algorithm>


#include "crc.h"
#include "setup_package_udp.h"


static const char *usage =  " -p номер порта (default: 2173); \n"
                            " -a ip адресс сервера (127.0.0.1) \n"
                            " -f [] \n"
                            " -h help";

using namespace std;

void make_form(****)
{
  }


void exchange_time(int i, int j, time_Hms_st * x)
{
    time_Hms_st tmp;
    tmp = x[i];
    x[i] = x[j];
    x[j] = tmp;

    return;
}

bool time_comparison(time_Hms_st & arr_time_1, time_Hms_st & arr_time_2)
{
    bool ret = false;

    if(arr_time_1.hour == arr_time_2.hour)
    {
        if(arr_time_1.min == arr_time_2.min)
        {
            if(arr_time_1.sec > arr_time_2.sec)
                ret = true;
        }
        else if (arr_time_1.min > arr_time_2.min)
            ret = true;
    }
    else if (arr_time_1.hour > arr_time_2.hour)
        ret = true;
    return ret;
}


void time_sort_shell(int n, time_Hms_st * time)
{
    int h, i, j;
    for (h = n / 2 ; h > 0 ; h = h / 2)
    {
        for (i = 0 ; i < n - h ; i++)
        {
            for (j = i ; j >= 0 ; j = j - h)
            {
                if(time_comparison(time[j], time[j + h]))          
                    exchange_time(j, j + h, time);
                else
                    j = 0;
            }
        }
    }

    return;
}


int make_diff(time_Hms_st & t1, time_Hms_st & t2)
{
    int diff = 0;
    if(t1.sec < t2.sec)
        diff = t2.sec - t1.sec;

    if(t1.min < t2.min)
    {
        diff += t2.min * 60 - t1.min * 60;
        if(t1.sec > t2.sec)
            diff -= t1.sec - t2.sec;
    }
    else if(t1.min > t2.min)
    {
        if(t1.hour == t2.hour)
            diff = -1;
    }

    if(t1.hour < t2.hour)
    {
        diff += t2.hour * 3600 - t1.hour * 3600;
        if(t1.min > t2.min)
            diff -= t1.min * 60 - t2.min * 60;
    }
    else if (t1.hour > t2.hour)
        diff = -1;

    return diff;
}


int main(int argc, char * argv[])
{
    printf("\n\n========  КЛИЕНТ udp (-h help)  ========\n");

    int opt = 0;
    uint16_t port_input = 2173;
    string address = "127.0.0.1";
    uint8_t flag_type_form[MAX_NUMBER_TYPE_FORM] = { 1, 1, 1,  1, 1, 1 };

//-----------------  Обработка входных парметров
    while((opt = getopt(argc, argv, "p:a:f:h")) != -1)
    {
        switch(opt)
        {
            case 'p':
                port_input = atoi(optarg);
            break;
            case 'h':
                puts(usage);
                return 0;
            break;
            case 'a':
            {
                address.clear();
                address.append(optarg);
            }
            break;
            case 'f':
            {
                memset(flag_type_form, 0, sizeof(flag_type_form));
                uint8_t buf = atoi(optarg);
                if(buf < 6)
                    flag_type_form[buf] = 1;
            }
            break;
            default:
            {
                printf("Задан неизвестный параметр\n");
                return 0;
            }
            break;
        }
    }

    printf("======= Подготовка данных для работы =============\n");

    ifstream file_in[MAX_NUMBER_TYPE_FORM];
    string path_arr [MAX_NUMBER_TYPE_FORM];
    path_arr[TYPE_A**].append("**.txt");
    path_arr[TYPE_B**].append("**.txt");
    path_arr[TYPE_D**].append("**.txt");
    path_arr[TYPE_J**].append("**.txt");
    path_arr[TYPE_R**].append("**.txt");
    path_arr[TYPE_T**].append("**.txt");

    vector <vector <data_form_st>> data_form[MAX_NUMBER_TYPE_FORM];

    vector <time_Hms_st> time_Hms_vec;

    //Буферы для вычитывания и сравнения
    data_form_st data_form_buf;

    printf("======= Открытие файлов и вычитывание дааных =============\n");
    for(unsigned count_type = 0; count_type < MAX_NUMBER_TYPE_FORM; count_type++)
    {
        if(flag_type_form[count_type])
        {
            file_in[count_type].open((char*)path_arr[count_type].c_str(), ios::in);
            if(!file_in[count_type])
                cout << "ERR: no file open - " << path_arr[count_type] << endl;
            else
            {
                bool flag_read = true;
                string buf_time_comp;
                string buf_time_comp_2;
                vector <data_form_st> data_form_vec;
                time_Hms_st time_Hms;
                unsigned count_for_vector = 0;
                unsigned count_read = 0;
                while(flag_read)
                {
                    data_form_buf.reset();
                    if((count_type == TYPE_R**) || (count_type == TYPE_D**) || (count_type == TYPE_J**) || (count_type == TYPE_T**))
                    {
                        file_in[count_type] >> data_form_buf.bear;    
                        file_in[count_type] >> data_form_buf.time;    
                    }
                    else if((count_type == TYPE_A**) || (count_type == TYPE_B**))
                    {
                        file_in[count_type] >> data_form_buf.bear;    
                        file_in[count_type] >> data_form_buf.dist;    
                        file_in[count_type] >> data_form_buf.time;    
                    }
                    if(!file_in[count_type].eof())
                    {
                        count_read++;
                        buf_time_comp.clear();
                        buf_time_comp.append(data_form_buf.time);

                        if(buf_time_comp_2.size())
                        {
                            if(buf_time_comp != buf_time_comp_2)
                            {
                                #ifdef DEBUG_READ_SORT
                                printf("count_for_vector = %u: count_type = %u:   t1 = %s   t2 = %s \n",  count_for_vector, count_type, buf_time_comp.c_str(), buf_time_comp_2.c_str());

                                printf("data_form[count_type] Перед push_back: size = %lu\n", data_form[count_type].size());
                                #endif

                                data_form[count_type].push_back(data_form_vec);

                                transfom_time(time_Hms, buf_time_comp_2);
                                time_Hms.type = count_type;
                                time_Hms.position = count_for_vector;
                                time_Hms_vec.push_back(time_Hms);
                                count_for_vector++;

                                //Новый список
                                data_form_vec.clear();
                                #ifdef DEBUG_READ_SORT
                                printf("Обновление count_for_vector = %u vec.size =%lu\n", count_for_vector, data_form_vec.size());
                                #endif
                                data_form_vec.push_back(data_form_buf);
                                buf_time_comp_2 = buf_time_comp;

                             }
                             else
                             {
                                data_form_vec.push_back(data_form_buf);
                                #ifdef DEBUG_READ_SORT
                                printf("~~~~~ == ~~~~~~ count_for_vector = %u: count_type = %u:   t1 = %s   t2 = %s \n",  count_for_vector, count_type, buf_time_comp.c_str(), buf_time_comp_2.c_str());
                                printf("vec.push_back: size = %lu \n", data_form_vec.size());
                                #endif
                             }
                        }
                        else
                        {
                            buf_time_comp_2 = buf_time_comp;
                            data_form_vec.push_back(data_form_buf);
                            #ifdef DEBUG_READ_SORT
                            printf("~~~~~ Первое чтение \n");
                            printf("vec.push_back: size = %lu \n", data_form_vec.size());
                            #endif
                        }
                    }
                    else
                    {
                        flag_read = false;
                        #ifdef DEBUG_READ_SORT
                        printf("LAST: count_type = %u:   t1 = %s   t2 = %s \n", count_type, buf_time_comp.c_str(), buf_time_comp_2.c_str());
                        #endif
                        if(count_read >= 1)
                        {

                            data_form[count_type].push_back(data_form_vec);
                            data_form_vec.clear();
                            transfom_time(time_Hms, buf_time_comp_2);
                            time_Hms.type = count_type;
                            time_Hms.position = count_for_vector;
                            time_Hms_vec.push_back(time_Hms);
                        }

                        file_in[count_type].close();
                    }
                }//while(flag_read)
            }//else
        }//if(flag_type_form[count_type])
    }//for



    printf("======= Сортировка времени =============\n");

    printf("======= Массив времени до сортировки=============\n");
    printf("SIZE = %lu \n", time_Hms_vec.size());
    size_t size_arr_time = time_Hms_vec.size();
    time_Hms_st * arr_time = new (nothrow) time_Hms_st [size_arr_time];
    if(arr_time == NULL)
    {
        printf( "ERR: new (time_Hms_st * arr_time) - errno = %s \n", strerror(errno));
        return -1;
    }


    for(unsigned i = 0; i < time_Hms_vec.size(); i++)
    {
        //printf("type = %u pos = %u      h = %u  m = %u  s = %u \n", time_Hms_vec[i].type, time_Hms_vec[i].position,
         //                                                           time_Hms_vec[i].hour, time_Hms_vec[i].min, time_Hms_vec[i].sec);
        arr_time[i] = time_Hms_vec[i];
    }

    time_Hms_vec.clear();
    
	//printf("======= Массив времени до сортировки=============\n");
    //printf("SIZE = %lu \n", time_Hms_vec.size());
    //for(unsigned i = 0; i < size_arr_time; i++)
    //{
        //printf("type = %u pos = %u      h = %u  m = %u  s = %u \n", arr_time[i].type, arr_time[i].position,
          //                                                          arr_time[i].hour, arr_time[i].min, arr_time[i].sec);
    //}


    
    time_sort_shell(size_arr_time, arr_time);
	
	//printf("======= Массив времени после сортировки =============\n");
    //for(unsigned i = 0; i < size_arr_time; i++)
    //{
    //    printf("type = %u pos = %u      h = %u  m = %u  s = %u \n", arr_time[i].type, arr_time[i].position,
    //                                                               arr_time[i].hour, arr_time[i].min, arr_time[i].sec);
    //}


******
******
******

    int number_pack_form[MAX_NUMBER_TYPE_FORM];

    for(unsigned i = 0; i < MAX_NUMBER_TYPE_FORM; i++)
    {
        number_pack_form[i] = size_form[i] / UDP_DATA_SIZE_BYTE;
        if(size_form[i] % UDP_DATA_SIZE_BYTE)
            number_pack_form[i] += 1;
        printf("%u: %u \n", i, number_pack_form[i]);
        printf("%u: %lu \n", i, size_form[i]);
    }

    uint8_t * data_send[MAX_NUMBER_TYPE_FORM];
    for(unsigned i = 0; i < MAX_NUMBER_TYPE_FORM; i++)
    {
        data_send[i] = new (nothrow) uint8_t [UDP_DATA_SIZE_BYTE * number_pack_form[i]];
        if(data_send[i] == NULL)
        {
            printf( "ERR: new (data_send[i]) - errno = %s \n", strerror(errno));
            return -1;
        }
    }


    printf("======= Клиент UDP =============\n");
    printf("======= port = %u \n", port_input);
    printf("======= address = %s \n", (char *)address.c_str());

    uint32_t marker_package_begin = 0xffffffaa;
    uint32_t marker_package_end = 0xffffff55;

    int socfd = -1;

    struct addrinfo * res_add = NULL;
    struct addrinfo * res_add_buf = NULL;
    struct addrinfo hints_add;

    memset(&hints_add, 0, sizeof(addrinfo));

    hints_add.ai_family = AF_INET;
    hints_add.ai_socktype = SOCK_DGRAM;

    string num_port;
    num_port.append(to_string(port_input));
    int ret_getadd = getaddrinfo(address.c_str(), num_port.c_str(), &hints_add, &res_add);
    if(ret_getadd != 0)
         printf( "ERR: getaddrinfo - errno = %s \n", strerror(errno));
    else
    {
        for(res_add_buf  = res_add; res_add_buf; res_add_buf = res_add_buf->ai_next)
        {
            errno = 0;
            socfd = socket(res_add_buf->ai_family, res_add_buf->ai_socktype,
                               res_add_buf->ai_protocol);
            if(socfd < 0)
                printf( "ERR: socket - errno = %s \n", strerror(errno));
            else
            {
                errno = 0;
                int ret_connect = connect(socfd, res_add_buf->ai_addr, res_add_buf->ai_addrlen);
                if(ret_connect < 0)
                    printf( "ERR: connect() - errno = %s \n", strerror(errno));
                else
                    printf( "OK: connect() - socfd = %i \n", socfd);
            }
        }
      }


    unsigned count_mess = 0;
    package_udp_st package_udp;
    data_form_st data_of_arr;
    time_Hms_st t1;
    time_Hms_st t2;
    memset(&t2, 0, sizeof(t2));

    printf("======= Цикл отправки формуляров: size_arr_time = %lu =============\n", size_arr_time);
    for(unsigned t = 0; t < size_arr_time; t++)
    {
        t1 = arr_time[t];
        size_t size_vec = data_form[arr_time[t].type][arr_time[t].position].size();
        printf("type = %u position = %u size_vec = %lu\n", arr_time[t].type, arr_time[t].position, size_vec);
        if(t)
        {
            printf("type=%u: t1.h = %u t1.m = %u t1.s = %u | type=%u: t2.h = %u t2.m = %u t2.s = %u \n",
                                            t1.type, t1.hour, t1.min, t1.sec, t2.type, t2.hour, t2.min, t2.sec);
            int diff = make_diff(t2, t1);
            if(diff == -1)
            {
                printf("ERR (t1 > t2): diff_time t1.h = %u t1.m = %u t1.s = %u | t2.h = %u t2.m = %u t2.s = %u \n",
                                                t1.hour, t1.min, t1.sec, t2.hour, t2.min, t2.sec);
                return -1;
            }
            else
            {
                printf("Спать diff = %i \n", diff);
                sleep(diff);
            }
        }
        t2 = t1;


        for(unsigned count_vec = 0; count_vec < size_vec; count_vec++)
        {
            data_of_arr.reset();
            memset(data_send[arr_time[t].type], 0, UDP_DATA_SIZE_BYTE * number_pack_form[arr_time[t].type]);
            data_of_arr = data_form[arr_time[t].type][arr_time[t].position][count_vec];
            switch(arr_time[t].type)
            {
                case TYPE_A**: { 
                    form_A.bear = data_of_arr.bear;
                    form_A.dist = data_of_arr.dist;
                    memcpy(form_A.time, data_of_arr.time, 36);
                    memcpy(data_send[arr_time[t].type], &form_A, size_form[arr_time[t].type]);
                } break;
                case TYPE_B**: {
                    form_B.bear = data_of_arr.bear;
                    form_B.dist = data_of_arr.dist;
                    memcpy(form_B.time, data_of_arr.time, 36);
                    memcpy(data_send[arr_time[t].type], &form_B, size_form[arr_time[t].type]);

                } break;
                case TYPE_D**: { //2 - пакета
                    form_D.bear = data_of_arr.bear;
                    memcpy(form_D.time, data_of_arr.time, 36);
                    memcpy(data_send[arr_time[t].type], &form_D, size_form[arr_time[t].type]);
                } break;
                case TYPE_J**: { //2-пакета
                    form_J.bear = data_of_arr.bear;
                    memcpy(form_J.time, data_of_arr.time, 36);
                    memcpy(data_send[arr_time[t].type], &form_J, size_form[arr_time[t].type]);
                } break;
                case TYPE_R**: {
                    form_R.bear = data_of_arr.bear;
                    memcpy(form_.time, data_of_arr.time, 36);
                    memcpy(data_send[arr_time[t].type], &form_R, size_form[arr_time[t].type]);
                } break;
                case TYPE_T**: { //2 - пакета
                    form_T.bear = data_of_arr.bear;
                    memcpy(form_.time, data_of_arr.time, 36);
                    memcpy(data_send[arr_time[t].type], &form_T, size_form[arr_time[t].type]);
                } break;
            }
            count_mess++;
            for(int count_pack = 0; count_pack < number_pack_form[arr_time[t].type]; count_pack++)
            {
				memset(&package_udp, 0, sizeof(package_udp));
				memcpy(&(package_udp.marker_begin), &marker_package_begin, UDP_MARKER_SIZE_BYTE);
				memcpy(&(package_udp.marker_end), &marker_package_end, UDP_MARKER_SIZE_BYTE);
				
				package_udp.header.num_message = count_mess;
				package_udp.header.number_package = number_pack_form[arr_time[t].type];
				package_udp.header.num_package = count_pack + 1;

				memcpy(package_udp.data, data_send[arr_time[t].type] + (count_pack * UDP_DATA_SIZE_BYTE), UDP_DATA_SIZE_BYTE);

				package_udp.checksum = crc8_polynomial7((uint8_t *)&package_udp + UDP_MARKER_SIZE_BYTE, sizeof(header_package_udp_st) + UDP_DATA_SIZE_BYTE);


				if(send(socfd, &package_udp, UDP_SIZE_PACKAGE, 0) < 0)
				{
					printf("ERR: sendto() - errno = %s \n", strerror(errno));
					close(socfd);
					delete [] arr_time;
					for(unsigned i = 0; i < MAX_NUMBER_TYPE_FORM; i++)
						delete [] data_send[i];
					return -1;
				}
				else
                    printf("COUNT_MESS = %u \n", count_mess);
            }
        } //цикл по вектру с данными для формуляров
    } // цикл по массиву времени

    printf("itog - COUNT_MESS = %u \n", count_mess);
    sleep(1000);
    close(socfd);
    delete [] arr_time;
    for(unsigned i = 0; i < MAX_NUMBER_TYPE_FORM; i++)
        delete [] data_send[i];
    return 0;
}