Ошибка Fatal glibc error: malloc.c:2599

// g.useragent_masks_desktop_count
if(main_data.config_key == 20){
 
    // realloc
    g.useragent_masks_desktop_malloc += sizeof(char *);
 
    printf("Hello\n");
    g.useragent_masks_desktop = realloc(g.useragent_masks_desktop, g.useragent_masks_desktop_malloc);
 
    printf("Hello\n");
    if(g.useragent_masks_desktop == NULL){
        printf("Error: loc memory [useragent_masks_desktop]\n");
        main_data.config_error = 1;
        break;
    }
 
 
    // malloc
    main_data.uli4 = strlen(main_data.char2) + 1;
    g.useragent_masks_desktop[ g.useragent_masks_desktop_count ] = (char *) malloc(main_data.uli4);
 
    if(g.useragent_masks_desktop[ g.useragent_masks_desktop_count ] == NULL){
        printf("Error: malloc [useragent_masks_desktop -> key]\n");
        main_data.config_error = 1;
        break;
    }
    memset(&g.useragent_masks_desktop[ g.useragent_masks_desktop_count ][0], 0, main_data.uli4);
 
 
    // cpy
    strcpy(g.useragent_masks_desktop[ g.useragent_masks_desktop_count ], main_data.char2);
    g.useragent_masks_desktop_count++;
}

struct global {
    char ** useragent_masks_desktop; // 2d array
};

main_data.uli4 = strlen(main_data.char2) + 1;
g.useragent_masks_desktop[ g.useragent_masks_desktop_count ] = (char *) malloc(main_data.uli4);

g.useragent_masks_desktop[ g.useragent_masks_desktop_count ]

// DataBase
unsigned long long int db_malloc;
 
// -> [tables]
char ** db_table_names;                          // key_table
unsigned int db_tables_count;
unsigned long int db_tables_malloc_keys,
                  db_tables_malloc_values;
 
// -> [dirs]
unsigned int ** db_tables_dirs_names;            // [key_table] _ [dir_key]
unsigned int ** db_tables_dirs_write_counts;     // [key_table] _ [dir_key]
unsigned int * db_tables_dirs_count;             // [key_table]
unsigned long int db_tables_dirs_malloc;
 
// g->db_table_names[ g->db_tables_count ]
 
// columns [DataBase]
// char ** db_column_keys;                       // "[key_table]_[key_column]"
 
// -> [columns]
unsigned long int * db_column_offsets,
                    db_column_malloc_keys,       // [key_table]
                    db_column_malloc_values;
unsigned int * db_column_counts;                 // [key_table]
 
char ** db_column_names;                         // [offset, counts]
bool * db_column_types,                          // [offset, counts] - переделать из bool в unsigned int ...
                                                 // 0-9 (char ... unsigned long int ... long double) - доделать
 
     * db_column_positions;                      // [offset, counts], 0 - content, 1 - name_file
 
unsigned long int db_colimns_all;
 
// -> [cells]
char ** db_cells_char;
long long int * db_cells_int;
bool * db_cells_change;
unsigned long long int db_cells_malloc_keys,
                       db_cells_malloc_values;
 
unsigned long int db_cells_count,
                ** db_write_positions,           // [key_table]
                * db_increments;                 // [key_table]
unsigned long long int db_write_pos_1_malloc,
                * db_write_pos_2_malloc;         // [key_table]

/* Модуль для работы с файлами настроек - заголовочный файл */
 
 
#ifndef inifiles_h
#define inifiles_h
 
#include "strutils.h"
#include <stdio.h>
 
 
/* -------------------------------- макросы --------------------------------- */
 
#define DEFAULT_FNAME   "settings.ini"
#define LETTERS         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"\
                        "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзиёклмнопрстуфхцчшщъыьэюя"
#define VALUE_CHARS     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_0123456789"\
                        "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзиёклмнопрстуфхцчшщъыьэюя"
 
#define VALUE_DIVIDER   '='
#define COMMENT_DELIM ';'
#define MAX_STR_LEN     256 // длина буферов для работы с текстовым файлом
 
#define FIRST_INDEX     0
#define LAST_INDEX      -1
 
#define IS_LETTER(c)       strchr(LETTERS, c)
#define IS_VALID_SYMBOL(c) strchr(VALUE_CHARS, c)
 
/* ------------------------------ типы данных ------------------------------- */
typedef char  TCharBuf[MAX_STR_LEN];
 
typedef struct TIniItem
{
  string Ident;       // идентификатор
  string Value;       // строковое значение
  string Comment;     // комментарий
  int    Index;       // номер в списке по порядку добавления
  struct TIniItem* PrevItem; // указатель на предыд. в списке
  struct TIniItem* NextItem; // указатель на след. в списке
} TIniItem, *PIniItem;
 
typedef struct TIniFile
{
  string FileName; // имя файла
  FILE* F;         // декриптор файла
  PIniItem Items;  // связанный список контента
} TIniFile, *PIniFile;
 
typedef struct TStringPair
{
  TCharBuf Left, Right;
  char Divider; // символ разделитель
} *PStringPair;
 
/* -------------------------------- функции API ----------------------------- */
 
void ifClearFile(PIniFile);
void ifPrintItem(PIniItem);
string ifStringItem(string s, PIniItem item);
void ifPrintFile(PIniFile);
bool ifLoadFromFile(PIniFile, string);
WORD ifCount(PIniFile);
PIniItem ifFindItem(PIniFile, const string);
 
string ifReadString(PIniFile, const string, const string);
bool ifReadBool(PIniFile, const string, const bool);
int ifReadInt(PIniFile, const string, const int);
long ifReadLong(PIniFile, const string, const long);
float ifReadFloat(PIniFile, const string, const float);
double ifReadDouble(PIniFile, const string, const double);
 
#endif //inifiles_h

/******************************************************************************/
/*                    Модуль для работы с файлами настроек                    */
/*                      Начат 05.10.2017   by Verevkin                        */
/*                      Версия 1.6, от 2 ноября 2019                          */
/******************************************************************************/
 
#include "inifiles.h"
 
/* ========================== сервисные функции ========================= */
bool ValidateIdent(string s)
{
  if (!s || !strlen(s) || !IS_LETTER(*s++)) return false;
  while (*s) if (!IS_VALID_SYMBOL(*s++)) return false;
  return true;
}
 
/*void AddItem2Log(string info, PIniItem item)
{
  char buf[256];
  sprintf(buf, "[%s] - %s = %s ; %s", info, item->Ident, item->Value, item->Comment);
  //Add2Log(buf);
} */
 
/* ======== функции для работы с динамической памятью (hardcore!) ======= */
 
// выделение памяти под опцию
PIniItem NewItem(string ident, string value, string comment)
{
  PIniItem result  = (PIniItem)malloc(sizeof(TIniItem));
  // выделение памяти с копированием:
  result->Ident    = strdup(ident);     // инициализация идентификатора
  result->Value    = strdup(value);     // значения
  result->Comment  = strdup(comment);   // и комментария
  result->PrevItem = NULL;              // очистка от мусора
  result->NextItem = NULL;              // очистка от мусора
  return result;
}
 
// освобождение памяти из-под опции с проверкой
void FreeItem(PIniItem item)
{
  if (item)
  {
    strfree(item->Ident);
    strfree(item->Value);
    strfree(item->Comment);
    free(item);
  }
}
 
void SetValue(PIniItem item, string value)
{
  if (!item) return;
  if (item->Value) free(item->Value); // если занято - освобождаю память
  item->Value = strdup(value);        // копирование значения
}
 
void SetComment(PIniItem item, string comment)
{
  if (!item) return;
  if (item->Comment) free(item->Comment); // если занято - освобождаю память
  item->Comment = strdup(comment);        // копирование значения
}
 
/* парсинг строки. если удачно - создаёт и возвращает объект TIniItem,
   иначе вернёт NULL.
   формат валидной строки:
   [пробелы, табы]ident[пробелы, табы]value[пробелы, табы][# комментарий]\0
 
   Алгоритм:
     1. найти начало комментария ";" скопировать в переменные всё, что слева и справа
     2. обрезать идент слева и справа (< #33) и проверить затем на валидность.
     3. скопировать в значение кусок строки от "=" до ";" (или до конца строки/0D/0A)
     4. скопировать в комментарий кусок от ";", если есть */
PIniItem ParseLine(string s)
{
  TCharBuf left, middle, right; // буфера под лексемы
 
  string divider_ptr = strchr(s, COMMENT_DELIM); // поиск начала комментария
 
  // обнуление буферов
  ZEROMEM(left, sizeof(TCharBuf));
  ZEROMEM(middle, sizeof(TCharBuf));
  ZEROMEM(right, sizeof(TCharBuf));
 
  if (divider_ptr) // если найден ";"
  {
    strtrimr(right, divider_ptr + 1); // копирую во временный буфер с очисткой справа
    *divider_ptr = 0; // и обрубаю по ";"
  }
 
  // оставшийся кусок строки распарсить как пару по "="
  divider_ptr = strchr(s, VALUE_DIVIDER); // поиск разделителя идента и значения
  if (!divider_ptr) return NULL; // если не найден "=", то это строка не содержит опции - на выход
 
  // сюда дойдёт, если оставшийся кусок - пара
  strtrim(middle, divider_ptr + 1); // копирую значение во временный буфер с очисткой слева и справа
  *divider_ptr = 0; // и обрубаю по "="
 
  // копирую идент во временный буфер с очисткой слева и справа
  strtrim(left, s);
  if (!ValidateIdent(left)) return NULL;
 
  // и только если есть валидный идент, состоящий из букв и цифр
  // и начинающийся с буквы, создаю новую запись.
  return NewItem(left, middle, right);    // выделение памяти, копирование и возврат
}
 
// получение ссылки на начальный, конечный элемент,
// или на элемент с номером 0 <= index < Count.
// для получения конечного элемента используется номер LAST_INDEX = -1.
// если элемента не существует, возвращается NULL.
PIniItem GetItem(PIniFile ini, int index)
{
  int idx = 0;
  PIniItem result = NULL;
  if (!ini || !ini->Items) return NULL;
 
  result = ini->Items;
  while (result)
  {
    if (index == LAST_INDEX && !result->NextItem) break; // найден последний
    if (index == idx) break; // найден по номеру
    result = result->NextItem; // переход на следующий
    idx++;
  }
 
  return result;
}
 
// добавление опции в конец списка. возвратит номер добавленного элемента
// или -1 при ошибке
int AddItem(PIniFile ini, PIniItem item)
{
  PIniItem last = NULL;
  if (!ini || !item) return -1;
 
  last = GetItem(ini, LAST_INDEX);
 
 
  if (last) last->NextItem = item, item->Index = last->Index + 1;
  else ini->Items = item, item->Index = 0;
 
  item->PrevItem = last;
  item->NextItem = NULL;
  return item->Index;
}
 
/* ------------------ функции, доступные извне --------------- */
// очистка списка параметров
void ifClearFile(PIniFile ini)
{
  PIniItem item, next = NULL;
  //printf("ifClearFile() - enter\n");
  if (!ini) return;
 
  item = ini->Items;
 
  while (item)
  {
    next = item->NextItem;
    FreeItem(item);
    item = next;
  }
  //printf("ifClearFile() - exit; ptr = %X\n", item);
 
  ini->Items = NULL;
}
 
void ifPrintItem(PIniItem item)
{
  printf("%s=%s;%s\n", item->Ident, item->Value, item->Comment);
}
 
string ifStringItem(string s, PIniItem item)
{
  sprintf(s, "%s=%s;%s", item->Ident, item->Value, item->Comment);
  return s;
}
 
void ifPrintFile(PIniFile ini)
{
  unsigned total = 0;
  PIniItem item = NULL;
 
  if (ini)
  {
    item = ini->Items;
 
    while (item)
    {
      ifPrintItem(item);
      item = item->NextItem;
      total++;
    }
  } // if
 
  printf(" [Total: %d]\n", total);
}
 
static char buffer_read[MAX_STR_LEN];
 
bool ifLoadFromFile(PIniFile ini, string FileName)
{
  PIniItem item;
  WORD count = 0;
 
  //printf("ifLoadFromFile() - enter\n");
  ZEROMEM(buffer_read, sizeof(buffer_read));
 
  ini->F = fopen(FileName, "rt");
  if (!ini->F) return false;
  ini->FileName = FileName;
 
  // чтение настроек из файла
  ifClearFile(ini);
 
  while (fgets(buffer_read, sizeof(buffer_read), ini->F))
  {
    //printf("buffer_read ---> %s", buffer_read); // debug
    assert(count < 10); // ЗОД : прога иногда виснет в этом цикле (а мож и не в этом)
    item = ParseLine(buffer_read);
    if (item) AddItem(ini, item), count++;
    //if (item) ifPrintItem(item); // debug
    ZEROMEM(buffer_read, sizeof(buffer_read));
  }
 
  // закрытие
  fclose(ini->F);
  //printf("ifLoadFromFile() - добавлено: %u\n", count);
  return true;
}
 
WORD ifCount(PIniFile ini)
{
  //printf("ifCount()\n");
  WORD result = 0;
  PIniItem item = ini->Items;
  while (item)
  {
    //AddItem2Log("count", item);
    result++;
    //printf(" ? result = %d\n", result);
    //getch();
    item = item->NextItem;
  }
 
  return result;
}
 
// поиск записи по иденту в списке. вернёт указатель на первый найденный
// или NULL, если не найден.
// Поиск регистрозависимый!
PIniItem ifFindItem(PIniFile ini, const string ident)
{
  PIniItem result = ini->Items;
 
  while (result)
  {
    if (strcmp(result->Ident, ident) == 0) break; // 0 ---> строки побайтно равны
    result = result->NextItem; // переход к след. элементу
  }
 
  return result;
}
 
// чтение строкового значения
string ifReadString(PIniFile ini, const string ident, const string defvalue)
{
  PIniItem item = ifFindItem(ini, ident);
  if (item) return item->Value;
  return defvalue; // по умолчанию
}
 
// чтение true / false
bool ifReadBool(PIniFile ini, const string ident, const bool defvalue)
{
  string s = ifReadString(ini, ident, NULL);
  if (!s) return defvalue; // не найден - по умолчанию
 
  // сравнение
  if (ARE_EQUAL(s, "false") || ARE_EQUAL(s, "FALSE")) return false;
  if (ARE_EQUAL(s, "true")  || ARE_EQUAL(s, "TRUE"))  return true;
  return defvalue; // некорректен - по умолчанию
}
 
// чтение 16-битного целого со знаком
int ifReadInt(PIniFile ini, const string ident, const int defvalue)
{
  int result;
  PIniItem item = ifFindItem(ini, ident);
  if (item && TryStr2Int(item->Value, &result)) return result;
  return defvalue; // по умолчанию
}
 
// чтение 32-битного целого со знаком
long ifReadLong(PIniFile ini, const string ident, const long defvalue)
{
  long result;
  PIniItem item = ifFindItem(ini, ident);
  if (item && TryStr2Long(item->Value, &result)) return result;
  return defvalue; // по умолчанию
}
 
// чтение 4-байтного вещественного со знаком
float ifReadFloat(PIniFile ini, const string ident, const float defvalue)
{
  float result;
  PIniItem item = ifFindItem(ini, ident);
  if (item && TryStr2Float(item->Value, &result)) return result;
  return defvalue; // по умолчанию
}
 
// чтение 8-байтного вещественного со знаком
double ifReadDouble(PIniFile ini, const string ident, const double defvalue)
{
  double result;
  PIniItem item = ifFindItem(ini, ident);
  if (item && TryStr2Double(item->Value, &result)) return result;
  return defvalue; // по умолчанию
}