decompress_for_all_z.c

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
                      #2023 X March 21 19:50 PM Brasília Time
 
*                                                                             *
*                   Licensa de Copia (C) <2023>  <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
                                                                             */
 
void init_vars_ric(my_thread_struct_z *amanda);
 
int THE_DECOMPRESSOR_FUNCION_NAME_Z(fdin, fdout, amanda)
FILE *fdin;
FILE *fdout;
my_thread_struct_z *amanda;
{
    init_vars_ric(amanda);
    REG2 char_type *stackp;
    REG3 code_int code;
    REG4 int finchar;
    REG5 code_int oldcode;
    REG6 code_int incode;
    REG7 int inbits;
    REG8 int posbits;
    REG9 int outpos;
    REG10 int insize;
    REG11 int bitmask;
    REG12 code_int free_ent;
    REG13 code_int maxcode;
    REG14 code_int maxmaxcode;
    REG15 int n_bits;
    REG16 int rsize;
 
    amanda->bytes_in = 0;
    amanda->bytes_out = 0;
    insize = 0;
 
    while (insize < 3 && (rsize = fread(amanda->inbuf + insize, 1, min(IBUFSIZ, amanda->size_of_input_file_copy_z), fdin)) > 0)
    {
        *((*amanda).bytes_read_z) += rsize;
        amanda->size_of_input_file_copy_z -= rsize;
        insize += rsize;
 
        while (*((*amanda).intpause_14))
        {
            Sleep(50);
            if (*((*amanda).intcancel_14))
            {
                amanda->internal_error_arp = 119;
                return 1;
            }
        }
 
        if (*((*amanda).intcancel_14))
        {
            amanda->internal_error_arp = 119;
            return 1;
        }
    }
 
    if (insize < 3 || amanda->inbuf[0] != MAGIC_1 || amanda->inbuf[1] != MAGIC_2)
    {
        if (rsize < 0)
            return 5;
 
        if (insize > 0)
        {
            /*
            fprintf(stderr, "%s: not in compressed format\n",
                    (ifname[0] != '\0' ? ifname : "stdin"));
            */
            amanda->exit_code = 1;
        }
 
        return 7;
    }
 
    amanda->maxbits = amanda->inbuf[2] & BIT_MASK;
    amanda->block_mode = amanda->inbuf[2] & BLOCK_MODE;
 
    if (amanda->maxbits > BITS)
    {
        /*
        fprintf(stderr,
                "%s: compressed with %d bits, can only handle %d bits\n",
                (*ifname != '\0' ? ifname : "stdin"), maxbits, BITS);
        */
        amanda->exit_code = 4;
        return 7;
    }
 
    maxmaxcode = MAXCODE(amanda->maxbits);
 
    amanda->bytes_in = insize;
    maxcode = MAXCODE(n_bits = INIT_BITS) - 1;
    bitmask = (1 << n_bits) - 1;
    oldcode = -1;
    finchar = 0;
    outpos = 0;
    posbits = 3 << 3;
 
    free_ent = ((amanda->block_mode) ? FIRST : 256);
 
    clear_tab_prefixof(); /* As above, initialize the first
                                                     256 entries in the table. */
 
    for (code = 255; code >= 0; --code)
        tab_suffixof(code) = (char_type)code;
 
    do
    {
    resetbuf:;
        {
            REG1 int i;
            int e;
            int o;
 
            o = posbits >> 3;
            e = o <= insize ? insize - o : 0;
 
            for (i = 0; i < e; ++i)
                amanda->inbuf[i] = amanda->inbuf[i + o];
 
            insize = e;
            posbits = 0;
        }
 
        if (insize < (int)(sizeof(amanda->inbuf) - IBUFSIZ))
        {
            if ((rsize = fread(amanda->inbuf + insize, 1, min(IBUFSIZ, amanda->size_of_input_file_copy_z), fdin)) < 0)
                return 5;
            /*
            processado_rspk += rsize;
 
            while(intpause___aakp)
            {
                Sleep(50);
 
                if(intcancel__rspk)
                {
                    return 119;
                }
            }
 
            if(intcancel__rspk)
            {
                return 119;
            }
            */
 
            while (*((*amanda).intpause_14))
            {
                Sleep(50);
                if (*((*amanda).intcancel_14))
                {
                    amanda->internal_error_arp = 119;
                    return 1;
                }
            }
 
            if (*((*amanda).intcancel_14))
            {
                amanda->internal_error_arp = 119;
                return 1;
            }
 
            *((*amanda).bytes_read_z) += rsize;
            insize += rsize;
            amanda->size_of_input_file_copy_z -= rsize;
        }
 
        inbits = ((rsize > 0) ? (insize - insize % n_bits) << 3 : (insize << 3) - (n_bits - 1));
 
        while (inbits > posbits)
        {
            if (free_ent > maxcode)
            {
                posbits = ((posbits - 1) + ((n_bits << 3) -
                                            (posbits - 1 + (n_bits << 3)) % (n_bits << 3)));
 
                ++n_bits;
                if (n_bits == amanda->maxbits)
                    maxcode = maxmaxcode;
                else
                    maxcode = MAXCODE(n_bits) - 1;
 
                bitmask = (1 << n_bits) - 1;
                goto resetbuf;
            }
 
            input(amanda->inbuf, posbits, code, n_bits, bitmask);
 
            if (oldcode == -1)
            {
                if (code >= 256)
                {
                    pedro_dprintf(2, "oldcode:-1 code:%i\n", (int)(code));
                    pedro_dprintf(2, "uncompress: corrupt input\n");
                    // abort_compress();
                    return 1;
                }
                amanda->outbuf[outpos++] = (char_type)(finchar = (int)(oldcode = code));
                continue;
            }
 
            if (code == CLEAR && amanda->block_mode)
            {
                clear_tab_prefixof();
                free_ent = FIRST - 1;
                posbits = ((posbits - 1) + ((n_bits << 3) -
                                            (posbits - 1 + (n_bits << 3)) % (n_bits << 3)));
                maxcode = MAXCODE(n_bits = INIT_BITS) - 1;
                bitmask = (1 << n_bits) - 1;
                goto resetbuf;
            }
 
            incode = code;
            stackp = de_stack;
 
            if (code >= free_ent) /* Special case for KwKwK string. */
            {
                if (code > free_ent)
                {
                    REG1 char_type *p;
 
                    posbits -= n_bits;
                    p = &amanda->inbuf[posbits >> 3];
 
                    pedro_dprintf(2, "insize:%d posbits:%d inbuf:%02X %02X %02X %02X %02X (%d)\n", insize, posbits,
                                  p[-1], p[0], p[1], p[2], p[3], (posbits & 07));
                    pedro_dprintf(2, "uncompress: corrupt input\n");
                    // abort_compress();
 
                    return 1;
                }
 
                *--stackp = (char_type)finchar;
                code = oldcode;
            }
 
            while ((cmp_code_int)code >= (cmp_code_int)256)
            { /* Generate output characters in reverse order */
                *--stackp = tab_suffixof(code);
                code = tab_prefixof(code);
            }
 
            *--stackp = (char_type)(finchar = tab_suffixof(code));
 
            /* And put them out in forward order */
 
            {
                REG1 int i;
 
                if (outpos + (i = (de_stack - stackp)) >= OBUFSIZ)
                {
                    do
                    {
                        if (i > OBUFSIZ - outpos)
                            i = OBUFSIZ - outpos;
 
                        if (i > 0)
                        {
                            memcpy(amanda->outbuf + outpos, stackp, i);
                            outpos += i;
                        }
 
                        if (outpos >= OBUFSIZ)
                        {
                            if (amanda->dest_is_FILE_z)
                            {
                                if ((int)fwrite(amanda->outbuf, 1, outpos, amanda->dest) != (int)outpos)
                                {
 
                                    amanda->internal_error_arp = 6;
                                    return 6;
                                }
                            }
                            else
                            {
                                if ((int)fwrite(amanda->outbuf, 1, outpos, fdout) != (int)outpos)
                                {
 
                                    amanda->internal_error_arp = 6;
                                    return 6;
                                }
                            }
                            amanda->size_of_destination_file_z += outpos;
 
                            outpos = 0;
                        }
                        stackp += i;
                    } while ((i = (de_stack - stackp)) > 0);
                }
                else
                {
                    memcpy(amanda->outbuf + outpos, stackp, i);
                    outpos += i;
                }
            }
 
            if ((code = free_ent) < maxmaxcode) /* Generate the new entry. */
            {
                tab_prefixof(code) = (unsigned short)oldcode;
                tab_suffixof(code) = (char_type)finchar;
                free_ent = code + 1;
            }
 
            oldcode = incode; /* Remember previous code.    */
        }
 
        amanda->bytes_in += rsize;
    } while (rsize > 0);
 
    if (amanda->dest_is_FILE_z)
    {
        if (outpos > 0 && (int)fwrite(amanda->outbuf, 1, outpos, amanda->dest) != (int)outpos)
        {
            amanda->internal_error_arp = 6;
            return 6; // cannot write to output file
        }
    }
    else
    {
        if (outpos > 0 && (int)fwrite(amanda->outbuf, 1, outpos, fdout) != (int)outpos)
        {
            amanda->internal_error_arp = 6;
            return 6; // cannot write to output file
        }
    }
    amanda->size_of_destination_file_z += outpos;
    return 0;
}