main_cr.c

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
                      #2023 X March 21 19:50 PM Brasília Time
 
*                                                                             *
*                   Licensa de Copia (C) <2024>  <Aurora Boreal>              *
*                                                                             *
*     Este  programa  e software livre: voce pode redistribuir isto e/ou      *
*     modificar  isto sobre os termos do  GNU Licensa Geral Pública como     25
*     publicado  pela Fundacao  de Software  Livre, tanto a versão 3  da      *
*     Licensa, ou (dependendo da sua opcao) qualquer versao posterior.        *
*                                                                             *
*     Este  programa e distribuido na  esperanca que isto vai  ser util,      *
*     mas SEM  QUALQUER GARANTIA; sem  ate mesmo a implicada garantia de      *
*     COMERCIALIZAcaO ou CABIMENTO PARA UM FIM PARTICULAR.  Veja a            *
*     Licensa Geral Publica para mais detalhes.                               *
*                                                                             *
*     Você deve ter recebido uma  cópia da LICENSA GERAL PUBLICA e a GNU      *
*     Licensa Publica Menor junto com este programa                           *
*     Se não, veja <http://www.gnu.org/licenses/>.                            *
*                                                                             *
*     Suporte: sourceforge.net github.com                                   *
*                                                                             *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
*       Pereira: arsoftware25@gmail.com ricardo@arsoftware.net.br             *
*           xcx: arsoftware10@gmail.com   charli@arsoftware.net.br            *
         Yasmin:                          yasmin@arsoftware.net.br            *
                                              pereira1001@users.sourceforge.net
                                                                             */
 
#include <windows.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <ctype.h>
#include <math.h>
#include <wctype.h>
#include <wchar.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <locale.h>
#include <signal.h>
#include <limits.h>
#include <float.h>
#include <iso646.h>
 
#undef NDEBUG
#include <assert.h>
 
#include <stdbool.h>
 
#include <process.h>
 
#ifndef uchar
#define uchar unsigned char
#endif
 
#ifndef uint
#define uint unsigned int
#endif
 
#ifndef ushort
#define ushort unsigned short
#endif
 
#ifndef __GNUC__
#define __attribute__(unused_ric_since_2004) /* yes... */
#endif
void convert_dl_ansi_to_wide(char *ansi_dl, WCHAR *wide_dl)
{
     int i_dl;
     int p_dl;
     p_dl = strlen(ansi_dl);
     for (i_dl = 0; i_dl < p_dl; i_dl++)
     {
          wide_dl[i_dl] = (WCHAR)ansi_dl[i_dl];
     }
     wide_dl[i_dl] = 0;
 
     return;
}
 
char *__stdcall widetochar_dl(
    WCHAR *pUSC2)
{
     static char dua_gone[(300 * 6) + 2];
     int i;
     int ret_dl;
 
     ret_dl = wcslen(pUSC2);
 
     for (i = 0; i < ret_dl; i++)
     {
          dua_gone[i] = (char)pUSC2[i];
     }
     dua_gone[i] = 0;
     return dua_gone;
}
char *__stdcall widetoutf8_dl(
    WCHAR *pUSC2)
{
     static int position = 0;
#define THESIZE (300 * 6)
     if (0 == position)
     {
          static char pUTF8[THESIZE];
          position = 1;
          WideCharToMultiByte(CP_UTF8, 0, pUSC2, -1, (LPSTR)pUTF8, THESIZE, 0,
                              0);
          return pUTF8;
     }
     else
     {
          static char pUTF8[THESIZE];
          position = 0;
          WideCharToMultiByte(CP_UTF8, 0, pUSC2, -1, (LPSTR)pUTF8, THESIZE, 0,
                              0);
          return pUTF8;
     }
     return NULL;
}
 
void usage1()
{
     /*
 
 
 
     */
 
     printf("Uso:\n\nPara criar um arquivo: val.exe -<opcoes> <caminho>\\sampleArchive.val <caminho>\\home\\sampleArchive '<wildcard>'");
     printf("\n\nPara extrair um arquivo: val.exe -<opcoes> <caminho>\\sampleArchive.val -C <caminho>\\samplePath\n\n");
     printf(
 
         " Opcoes\n\n"
         " c - criar arquivo \n"
         " v - verbose \n"
         " f - modo arquivo (sempre requerido no momento) \n"
         " z - usar gzip para compressao \n"
         " L - usar LZMA para compressao \n"
         " e - usar lz5 para compressao, lz5 é uma extensao da rapida compressao lz4 com suporte a multi-thread \n"
         " h - usar brotli2 para compressao, brotli2 é uma extensao de brotli com suporte a multi-thread \n"
         " j - usar gzip2 para compressao, gzip2 é uma extensao de gzip com suporte a multi-thread \n"
         " i - usar bzip3 para compressao, bzip3 é um modo extendido de bzip2 com suporte a multi-thread \n"
         " m - usar lzop2 para compressao, lzop2 é um modo extendido de lzop com suporte a multi-thread \n"
         " n - usar Zstandard para compressao \n"
         " o - usar xz para compressao, sem suporte a multi-thread \n"
         " q - usar brotli para compressao, este e o modo padrao de compressao brotli, sem suporte a multi-thread \n"
         " r - usar compress do Unix para compressao \n"
         " s - usar compress2 (derivado do compress de Unix) para compressao, isto e compress com multi-thread \n"
         " p[n] nivel de compressao onde [n] varia de 0 para 9, 9 melhor compressao \n"
         " B - usar bzip2 como metodo de compressao \n"
         " T[n] - where [n] is a value between 0 and 128 for the number of threads running the process, only works for compressors/decopressors that allows setting the threads running\n"
         " x - extrair arquivo, requer tambem -C como terceiro argumento da chamada \n\n");
     /*
 
 
 
     */
     printf("Para criar um arquivo val a partir do diretorio /home/sampleArchive incluindo todos os arquivos\nUsage "
            "val.exe -cvf <path>sampleArchive.val <path>/home/sampleArchive *\n"
            "\nPara criar um arquivo val usando metodo gzip a partir do diretorio /home/sampleArchive incluindo apenas arquivos *.txt e *.ini\nUsage "
            "val.exe -cvfzp6T16 <path>sampleArchive.val.gz <path>/home/sampleArchive '*.txt *.ini'\n"
            "In this case the compression level is 6, normal compression level, it range from 0 to 9 to maximum compression level"
            "\n\nPara criar um arquivo val usando metodo bzip2 a partir do diretorio <path>/home/sampleArchive incluindo todos os arquivos \nUsage "
            "val.exe -cvfBp6T8 <path>sampleArchive.val.bzip2 <path>/home/sampleArchive *\n"
            "\nPara extrair um arquivo val\nUsage val.exe -xvf <path>sampleArchive.val -C <path>/home/sampleArchive\n");
     exit(27);
}
int main(__attribute__((unused)) int argc_xcx, __attribute__((unused)) char **argv_xcx)
{
     char argv_xcx_2_dl[300 * 6] = {0};
     char argv_xcx_4_dl[300 * 6] = {0};
     ;
     char file_val_dl[300 * 6] = {0};
     char path_compress_dl[300 * 6] = {0};
     WCHAR path_compress_w_dl[300] = {0};
 
     int __stdcall GetReturnValueFromList(void);
     int __stdcall GetReturnValue_ar(void);
     int ret_value_arp = 0;
     int modo_xcx = NAO_DEFINIDO_XCX;
     int i_xcx;
     int compression_method_xcx = 6;
     bool ok_ric = false;
     short itens_charli;
     char character_cha;
     char buf_cr_level[3] = {0};
     char buf_cr_threads[4] = {0};
     char charli_char[300];
     // int deslocador_charli;
     int i_c;
     int priority_charli;
     // int ret_charli = 0;
     /*
 
 
 
 
 
 
 
 
 
 
 
 
     */
 
     priority_charli = 1;
 
     switch (priority_charli)
     {
     case 0:
 
          SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
          break;
     case 1:
 
          SetPriorityClass(GetCurrentProcess(),
                           NORMAL_PRIORITY_CLASS);
 
          break;
     case 2:
 
          SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS); // time critical mode only Microsoft can use...
          break;
     case 3:
 
          SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS); // time critical mode only Microsoft can use...
          break;
     default:
          break;
     }
 
     // printf("ret_charli %d\n\n", ret_charli);
 
     // exit(27);
     /*
 
 
 
 
 
 
 
 
 
 
 
 
 
     */
 
     if (1 < argc_xcx)
     {
 
          if ('-' == argv_xcx[1][0])
          {
               ok_ric = true;
          }
 
          itens_charli = strlen(argv_xcx[1]);
 
          for (i_xcx = 0; i_xcx < itens_charli; i_xcx++)
          {
               // printf("item : %s\n", argv_xcx[i_xcx]);
 
               if (true == ok_ric)
               {
                    character_cha = argv_xcx[1][i_xcx];
 
                    // printf("%c\n", character_cha);
 
                    if ('-' == character_cha)
                    {
                         continue;
                    }
 
                    if ('c' == character_cha)
                    {
                         modo_xcx = MODO_EH_COMPRESS;
                         compression_method_xcx = AAKP_MODE_VAL;
                    }
 
                    if ('z' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_GZIP;
                         // printf("Error, method standard gzip disabled for the moment\n");
                         // exit(27);
                    }
                    /*
                                    if ('0' <= character_cha && '9' >= character_cha)
                                    {
                                        buf_cr_level[0] = character_cha;
 
                                        compression_level_xcx = atoi(buf_cr_level);
 
                                        // printf("c level %d\n", compression_level_xcx);
                                    }
                    */
                    if ('B' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_BZ2;
                    }
 
                    if ('x' == character_cha)
                    {
                         modo_xcx = MODO_EH_UNCOMPRESS;
                    }
 
                    if ('p' == character_cha)
                    {
                         memset(buf_cr_level, 0, sizeof(buf_cr_level));
                         buf_cr_level[0] = argv_xcx[1][i_xcx + 1];
 
                         compression_level_xcx = atoi(buf_cr_level);
                         // printf("c level %d\n", compression_level_xcx);
                    }
 
                    if ('T' == character_cha)
                    {
                         // num_threads_xcx
                         memset(buf_cr_threads, 0, sizeof(buf_cr_threads));
 
                         for (i_c = 0; i_c < 3; i_c++)
                         {
                              if (0 == argv_xcx[1][i_xcx + i_c + 1])
                              {
                                   break;
                              }
                              if ('0' > argv_xcx[1][i_xcx + i_c + 1] && '9' < argv_xcx[1][i_xcx + i_c + 1])
                              {
                                   break;
                              }
                              buf_cr_threads[i_c] = argv_xcx[1][i_xcx + i_c + 1];
                         }
                         num_threads_xcx = atoi(buf_cr_threads);
 
                         if (128 < num_threads_xcx)
                         {
                              num_threads_xcx = 128;
                         }
                         threads_z = num_threads_xcx;
                         // printf("c threads %d\n", num_threads_xcx);
                    }
 
                    if ('L' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_LZMA;
                    }
 
                    if ('i' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_BZIP3;
                    }
 
                    if ('j' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_GZIP2;
                    }
 
                    if ('e' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_LZ5;
                    }
 
                    if ('h' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_BROTLI2;
                    }
 
                    if ('m' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_LZOP2;
                    }
 
                    if ('n' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_ZSTANDARD;
                    }
 
                    if ('o' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_XZ;
                    }
 
                    if ('q' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_BROTLI;
                    }
 
                    if ('r' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_COMPRESS;
                    }
 
                    if ('s' == character_cha)
                    {
                         compression_method_xcx = AAKP_MODE_VAL_COMPRESS2;
                    }
               }
               else
               {
                    printf("Primeiro item nas opcoes precisa ser o caracter '-', caracter usado '%c'\n\n", argv_xcx[1][0]);
                    usage1();
               }
          }
 
          // tar -xvf sampleArchive.tar -C /home/ExtractedFiles/
 
          if (modo_xcx == MODO_EH_UNCOMPRESS)
          {
 
               if (5 != argc_xcx)
               {
                    usage1();
               }
 
               if (0 != strcmp("-C", argv_xcx[3]))
               {
 
                    usage1();
               }
 
               (void)argv_xcx_2_dl;
               (void)argv_xcx_4_dl;
 
               // printf("veja %s\n", GetCommandLineA());
               {
 
                    void pedro_dprintfW(int amanda_level,
                                        wchar_t *format, ...);
 
                    LPWSTR *szArglist;
                    int nArgs;
                    int i;
                    {
                         szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
                         if (NULL == szArglist)
                         {
                              wprintf(L"CommandLineToArgvW failed\n");
                              return 0;
                         }
                         else
                              for (i = 0; i < nArgs; i++)
                              {
                                   // pedro_dprintfW(0, L"%d: %ls\n", i, szArglist[i]);
 
                                   if (2 == i)
                                   {
 
                                        // strcpy(path_compress_dl, widetoutf8_dl(szArglist[i]));
                                        strncpy_z(argv_xcx_2_dl, widetoutf8_dl(szArglist[i]), (300 * 6) - 2);
                                   }
 
                                   if (4 == i)
                                   {
 
                                        strncpy_z(argv_xcx_4_dl, widetoutf8_dl(szArglist[i]), (300 * 6) - 2);
                                        // _wunlink(szArglist[i]);
                                   }
                              }
                    }
 
                    // Free memory allocated for CommandLineToArgvW arguments.
 
                    LocalFree(szArglist);
               }
 
               yasmin_charlotte_pereira_dprintf(-1001, "veja amor -> %s", argv_xcx[2]);
               // charli4
 
               if ('\\' == argv_xcx[2][0])
               {
                    printf("Esta versão console não tem suporte a caminhos UNC\n\n");
                    usage1();
               }
               if ((MAX_PATH * 6) < strlen(argv_xcx_2_dl))
               {
                    printf("Caminho de arquivo muito longo, nesta versão console o caminho tem que ser inferior ou igual a %d\n\n", MAX_PATH);
                    usage1();
               }
               // charli2
               /*
                           unlink(argv_xcx[2]);
 
                           {
                               FILE *myfile = fopen(argv_xcx[2], "wb");
                               if(myfile)
                               {
                                   fclose(myfile);
                               }
                           }
               */
 
               strcpy(charli_and_yasmin_global_filename, argv_xcx_2_dl);
               time_uncompression_charli = get_bucaneiro_tick();
               ret_value_arp = extract_tar_file_ar(argv_xcx_2_dl, argv_xcx_4_dl); // problem with MAX_PATH
 
               if (ret_value_arp)
               {
                    printf("Uncompression error %d \n", ret_value_arp);
                    exit(27);
               }
               memset(charli_char, 0, sizeof(charli_char));
               while (running_2_ar)
               {
                    memory_usage__z2(charli_char);
                    printf("Progresso %d - Memoria: %s\r", GetExtrationProgress_ar() / 100, charli_char);
                    Sleep(50);
 
                    // return fatal_exit_k;
               }
               memory_usage__z(charli_char);
               printf("Progresso %d - Tempo Gasto: %f segundos - Memory: %s\n", 100, time_uncompression_charli, charli_char);
 
               if (fatal_exit_k)
                    printf("Uncompress error: %d\n", fatal_exit_k);
 
               return fatal_exit_k;
          }
 
          if (MODO_EH_COMPRESS == modo_xcx)
          {
               if (5 != argc_xcx)
               {
                    usage1();
                    // goto extrada;
               }
          }
 
          if (NAO_DEFINIDO_XCX == modo_xcx || 1 == argc_xcx)
          {
               printf("oi\n");
               usage1();
          }
 
          if (MODO_EH_COMPRESS == modo_xcx)
          {
 
               if ('\\' == argv_xcx[2][0])
               {
                    printf("Esta versão console não tem suporte a caminhos UNC\n\n");
                    usage1();
               }
 
               if (MAX_PATH < strlen(argv_xcx[2]))
               {
                    printf("Caminho de arquivo muito longo, nesta versão console o caminho tem que ser inferior ou igual a %d\n\n", MAX_PATH);
                    usage1();
               }
               if (MAX_PATH < strlen(argv_xcx[3]))
               {
                    printf("Diretorio dos arquivos muito longo, nesta versão console o caminho tem que ser inferior ou igual a %d\n\n", MAX_PATH);
                    usage1();
               }
 
               // printf("veja %s\n", GetCommandLineA());
               {
 
                    void pedro_dprintfW(int amanda_level,
                                        wchar_t *format, ...);
 
                    LPWSTR *szArglist;
                    int nArgs;
                    int i;
                    {
                         szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
                         if (NULL == szArglist)
                         {
                              wprintf(L"CommandLineToArgvW failed\n");
                              return 0;
                         }
                         else
                              for (i = 0; i < nArgs; i++)
                              {
                                   // pedro_dprintfW(0, L"%d: %ls\n", i, szArglist[i]);
 
                                   if (3 == i)
                                   {
 
                                        strncpy_z(path_compress_dl, widetoutf8_dl(szArglist[i]), (300 * 6) - 2);
                                   }
 
                                   if (2 == i)
                                   {
                                        // aqui
                                        strncpy_z(file_val_dl, widetoutf8_dl(szArglist[i]), (300 * 6) - 2);
                                        _wunlink(szArglist[i]);
                                   }
                              }
                    }
 
                    // Free memory allocated for CommandLineToArgvW arguments.
 
                    LocalFree(szArglist);
               }
               // pedro_dprintf(0, "oi");
               time___compression_charli = get_bucaneiro_tick();
               {
                    // convert_dl_ansi_to_wide(argv_xcx[3], path_compress_w_dl);
 
                    // strcpy(path_compress_dl, widetoutf8_dl(path_compress_w_dl));
                    (void)path_compress_w_dl;
               }
               // unlink(argv_xcx[2]); // need to be modified to allow file update, only fails in compress method mode
 
               // printf("path %s\n", argv_xcx[3]);
 
               ret_value_arp = create_archive_ar_v2(file_val_dl,
                                                    path_compress_dl,
                                                    argv_xcx[4],
                                                    compression_method_xcx,
                                                    true,
                                                    ARP_INCLUDE_FILES);
 
               if (ret_value_arp)
               {
 
                    printf("Error in the compression: %d \n", ret_value_arp);
                    exit(27);
               }
          }
          memset(charli_char, 0, sizeof(charli_char));
          while (running_ar)
          {
               memory_usage__z2(charli_char);
               if (0 == GetProgress_ar() / 100)
               {
                    printf("Iniciando...\r");
               }
               else
                    printf("Progresso %d - Memoria: %s\r", GetProgress_ar() / 100, charli_char);
 
               Sleep(50);
          }
          // assert(0);
          memory_usage__z(charli_char);
          printf("Progresso %d - Tempo Gasto: %f segundos - Memory: %s\n", 100, time___compression_charli, charli_char);
 
          if (GetReturnValue_ar())
          {
               printf("Error: %s\n", error_message_k);
               printf("Compress error, return value %d\n", GetReturnValue_ar());
               return 27;
          }
     }
     else
     {
          printf("\n\nFaltando argumentos\n\n");
          usage1();
     }
     return 0;
}