Написать простой аналог линуксового less - утечка памяти

#include <termios.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <getopt.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <locale.h>
#include <wchar.h>
 
#define min(a,b) ((a < b) ? a : b)
#define max(a,b) ((a > b) ? a : b)
 
const int MAX_LEN = 1000;
const char* error1 = "Error of the memory allocation.\n";
const char* error2 = "Error!\nFile with that name doesn't exist.\n";
const char* error3 = "Error reading from file.\n";
const char* error4 = "Command is incorrect.\n";
const char* error5 = "Error!\nWrong number of arguments.\n";
const char* error6 = "Error!\nYou are not redirected input from a terminal.\n";
const char* error7 = "Error of file.\n";
const char* error8 = "Error!\nUnknown parameter.\n";
struct termios old_attributes, new_attributes;
 
void Print(wchar_t** buf, int h_begin, int h_end, int w_begin, int w_end)
{
  fputws(L"\033[0d\033[2J", stdout);
 
  int i, j;
  for (i = h_begin; i < h_end; ++i)
  {
    for (j = w_begin; j < min(w_end, wcslen(buf[i])); ++j)
      fputwc(buf[i][j], stdout);
    fputwc(L'\n', stdout); 
  }
}
 
int CountOfNum(int a)
{
    int res = 0;
    if (!a)
        return 1;
    while (a > 0)
    {
        a /= 10;
        res ++;
    }
    return res;
}
 
void Print1(wchar_t** buf, int h_begin, int h_end, int w_begin, int w_end, int width, int buf_size)
{
  fputws(L"\033[0d\033[2J", stdout);
  int i, j, k;
  int end_w = 0;
  int COUNT = CountOfNum(buf_size);
  int count = 0;
  int temp = 0;
  int t = 0;
  for (i = h_begin; i < h_end; ++i)
  {
    if (w_begin)
        fputwc(L'<', stdout);
    else
        fputwc(L'|', stdout);
    count = CountOfNum(i + 1);
    temp = i + 1;
    char s[COUNT + 1];
    t = 0;
    while (temp > 0)
    {
        s[t] = (temp % 10) + L'0';
        t++;
        temp /= 10;
    }
    for (k = count - 1; k >= 0; --k)
        fputwc(s[k], stdout);
    for (k = 0; k < COUNT - count; ++k)
        fputwc(L' ', stdout); 
    width -= (COUNT + 2);
    if (w_end < width)
       width = w_end;
    int cur_size = 0;
    /*
    while (buf[i][cur_size] != L'\n')
        cur_size++;
    */
    if (buf[i] != NULL)
    {
        end_w = min(width, wcslen(buf[i]));
        fputwc(L':', stdout);
        for (j = w_begin; j < end_w; ++j)
        fputwc(buf[i][j], stdout);
    }
    fputwc(L'\n', stdout); 
  }
}
 
void Terminal_new(int* error)
{
  setlocale(LC_ALL, "ru_RU.utf8"); 
  if (!isatty(0))
  {
    printf(error6);
    *error = 6;
    return;
  }
  tcgetattr(0, &old_attributes );
  memcpy(&new_attributes, &old_attributes, sizeof(struct termios));
  new_attributes.c_lflag &= ~ECHO;
  new_attributes.c_lflag &= ~ICANON;
  new_attributes.c_cc[VMIN] = 1;
  new_attributes.c_cc[VTIME] = 0;
  tcsetattr(0, TCSANOW, &new_attributes);
}
 
void Terminal_old()
{
  tcsetattr(0, TCSANOW, &old_attributes);
}
 
wchar_t** ReadFile(wchar_t** buf, FILE* file, int* max_len_of_str, int* buf_size, int* error)
{
  int count_of_str = 0;
  buf[count_of_str] = (wchar_t*)malloc(MAX_LEN * sizeof(wchar_t));
  wchar_t c;
  int ind = 0;
  int buf_max_size = MAX_LEN;
  while((c = fgetwc(file)) != WEOF)
  {
    if (file == NULL)
    {
      printf(error7);
      Terminal_old();
      *error = 7;
      return;
    }
    if (c == L'\n' | c == L'\0')
    {
      count_of_str++;
      if (ind > *max_len_of_str)
        (*max_len_of_str) = ind;
      ind = 0;
      if (count_of_str > MAX_LEN - 1)
         buf = (wchar_t**)realloc((void*)buf, (count_of_str + 1) * sizeof(wchar_t*)); 
      buf[count_of_str] = (wchar_t*)malloc(buf_max_size * sizeof(wchar_t));
      if (buf[count_of_str] == NULL)
      {
        printf(error1);
        *error = 1; 
        return;
      }
    }
    else
      if (c == L'\t')
      {
        if (ind >= buf_max_size - 4)
        {
          buf_max_size += MAX_LEN;
          buf[count_of_str] = (wchar_t*)realloc(buf[count_of_str], buf_max_size * sizeof(wchar_t));
          if (buf[count_of_str] == NULL)
          {
            printf(error1);
            *error = 1; 
            return;
          }
          int j;
          for (j = 0; j < 4; ++j)
          {
            buf[count_of_str][ind] = L' ';
            ++ind;
          }
          continue;
        }
        buf[count_of_str][ind] = c;
        ind++;
        if (ind >= buf_max_size - 1)
        {
          buf_max_size += MAX_LEN;
          buf[count_of_str] = (wchar_t*)realloc (buf[count_of_str], buf_max_size * sizeof(wchar_t));
          if (buf[count_of_str] == NULL)
          {
            printf(error1);
            *error = 1; 
            return;
          }
        }   
      }
      else
      {
        buf[count_of_str][ind] = (wchar_t)c;
        ind++;
        if (ind >=  buf_max_size - 1)
        {
          buf_max_size += MAX_LEN;
          buf[count_of_str] = (wchar_t*)realloc(buf[count_of_str], buf_max_size * sizeof(wchar_t));
        }
      }
  }
  if (ind > 0) {
    if (ind > (*max_len_of_str))
      (*max_len_of_str) = ind;  
    count_of_str++;
  }
  else
      free(buf[count_of_str]);
  *buf_size = count_of_str;
 
  return buf;
}
 
void FreeBuf(wchar_t** buf, int buf_size)
{
  int i;
  for (i = 0; i < buf_size; ++i)
    free(buf[i]);
  free(buf);
}
 
void WorkTerminal(wchar_t** buf, int max_len_of_str, int buf_size, int is_param)
{
  struct winsize win_size;
  ioctl(0, TIOCGWINSZ, &win_size);
  int height = win_size.ws_row - 1;
  int width = win_size.ws_col;
  int shift_w = 0;
  int shift_h = 0;
  int h_begin = 0, h_end = min(buf_size, height);
  int w_begin = 0, w_end = min(max_len_of_str, width);
  int cur_c = 0;
  while (1)
  {
    if (is_param)
        Print1(buf, h_begin, h_end, w_begin, w_end, width,  buf_size);
    else
        Print(buf, h_begin, h_end, w_begin, w_end);
    cur_c = getchar();
    if (cur_c == 'q')
    {
      Terminal_old();
      return;
    }
    if (cur_c == 27)
    {
      cur_c = getchar();
      if (cur_c == 91)
      {
        cur_c = getchar();
        switch (cur_c)
        {
          case 65:/*up*/
            shift_h --;
            if (shift_h < 0)
              shift_h = 0;
            break;
          case 66:/*down*/
            if (shift_h < buf_size - height)
              shift_h ++;
            break;
          case 67:/*right*/
            if (shift_w < max_len_of_str - width)
              shift_w ++;
            break;
          case 68:
            shift_w --;
            if (shift_w < 0)
              shift_w = 0;
            break;  
        };
        h_begin = shift_h;
        h_end = min(buf_size, height + shift_h);
        w_begin = shift_w;
        w_end = min(max_len_of_str, width + shift_w);
      }
      if (cur_c == EOF)
        break;
    }
    if (cur_c == EOF || cur_c == '\004')
      break;
  }
}
 
int main(int argc, char* argv[])
{
  int error = 0;
  Terminal_new(&error);
  if (error)
    return error;
    
  if (argc < 2 || argc > 4)
  {
    printf(error5);
    Terminal_old();
    return 5;
  }
  char cc;
  int is_param = 0;/*flag = 1, if '-n'*/
  while ((cc = getopt(argc, argv, "n")) != -1)
    switch (cc)
    {
      case 'n':
        is_param = 1;
        break;
      case '?':
        printf(error8);
        break;
    };
 
  FILE* file = fopen(argv[optind], "r");
  if (file == NULL)
  {
    printf(error2);
    Terminal_old();
    return 2;
  }
  wchar_t** buf = (wchar_t**)malloc(MAX_LEN * sizeof(wchar_t*));
  if (buf == NULL)
  {
    printf(error1); 
    Terminal_old();
    return 1;
  }
  int max_len_of_str = 0;
  int buf_size = 0;
  buf = ReadFile(buf, file, &max_len_of_str, &buf_size, &error);
  if (error)
  {
    FreeBuf(buf, buf_size);
    return error;
  }
  fclose(file);
  
  WorkTerminal(buf, max_len_of_str, buf_size, is_param);
  Terminal_old();
  FreeBuf(buf, buf_size);
  return 0;
}