usbloadergx/source/unzip/miniunz.c

/*
   miniunz.c
   Version 1.01e, February 12th, 2005

   Copyright (C) 1998-2005 Gilles Vollant
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
# include <unistd.h>
# include <utime.h>

#include "unzip.h"

#define CASESENSITIVITY (0)
#define WRITEBUFFERSIZE (8192)
#define MAXFILENAME (256)

static int mymkdir( const char* dirname )
{
    int ret = 0;
    ret = mkdir ( dirname, 0775 );
    return ret;
}

int makedir ( char *newdir )
{
    char *buffer ;
    char *p;
    int  len = ( int )strlen( newdir );

    if ( len <= 0 )
        return 0;

    buffer = ( char* )malloc( len + 1 );
    strcpy( buffer, newdir );

    if ( buffer[len-1] == '/' )
    {
        buffer[len-1] = '\0';
    }
    if ( mymkdir( buffer ) == 0 )
    {
        free( buffer );
        return 1;
    }

    p = buffer + 1;
    while ( 1 )
    {
        char hold;

        while ( *p && *p != '\\' && *p != '/' )
            p++;
        hold = *p;
        *p = 0;
        if ( ( mymkdir( buffer ) == -1 ) && ( errno == ENOENT ) )
        {
//            printf("couldn't create directory %s\n",buffer);
            free( buffer );
            return 0;
        }
        if ( hold == 0 )
            break;
        *p++ = hold;
    }
    free( buffer );
    return 1;
}

static char *fullfilename( const char *basedir, char *filename )
{
    char *file = ( char * ) malloc( strlen( basedir ) + strlen( filename ) + 1 );
    if ( basedir == NULL )
    {
        strcpy( file, filename );
    }
    else
    {
        if ( basedir[strlen( basedir ) - 1] == '/' )
        {
            sprintf( file, "%s%s", basedir, filename );
        }
        else
        {
            sprintf( file, "%s/%s", basedir, filename );
        }
    }
    return file;
}

static int do_extract_currentfile( unzFile uf, const int* popt_extract_without_path, int* popt_overwrite, const char* password, const char *basedir )
{
    char filename_inzip[256];
    char* filename_withoutpath;
    char* filename_withpath;
    char* p;
    int err = UNZ_OK;
    FILE *fout = NULL;
    void* buf;
    uInt size_buf;

    unz_file_info file_info;
    err = unzGetCurrentFileInfo( uf, &file_info, filename_inzip, sizeof( filename_inzip ), NULL, 0, NULL, 0 );

    if ( err != UNZ_OK )
    {
//        printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
        return err;
    }

    size_buf = WRITEBUFFERSIZE;
    buf = ( void* )malloc( size_buf );
    if ( buf == NULL )
    {
//        printf("Error allocating memory\n");
        return UNZ_INTERNALERROR;
    }

    p = filename_withoutpath = filename_inzip;
    filename_withpath = fullfilename( basedir, filename_inzip );
    while ( ( *p ) != '\0' )
    {
        if ( ( ( *p ) == '/' ) || ( ( *p ) == '\\' ) )
            filename_withoutpath = p + 1;
        p++;
    }

    if ( ( *filename_withoutpath ) == '\0' )
    {
        if ( ( *popt_extract_without_path ) == 0 )
        {

            // Fix the path, this will fail if the directoryname is the same as the first filename in the zip
            char *path = ( char * ) malloc( strlen( filename_withpath ) );
            strcpy( path, filename_withpath );
            char *ptr = strstr( path, filename_withoutpath );
            *ptr = '\0';

//            printf("creating directory: %s\n",path);
            mymkdir( path );

            free( path );
        }
    }
    else
    {
        char* write_filename;
        int skip = 0;

        if ( ( *popt_extract_without_path ) == 0 )
            write_filename = filename_withpath;
        else
            write_filename = filename_withoutpath;

        err = unzOpenCurrentFilePassword( uf, password );
        if ( err != UNZ_OK )
        {
//            printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
        }

        if ( ( ( *popt_overwrite ) == 0 ) && ( err == UNZ_OK ) )
        {
            char rep = 0;
            FILE* ftestexist;
            ftestexist = fopen( write_filename, "rb" );
            if ( ftestexist != NULL )
            {
                fclose( ftestexist );
                do
                {
                    char answer[128];
                    int ret;

//                    printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
                    ret = scanf( "%1s", answer );
                    if ( ret != 1 )
                    {
                        exit( EXIT_FAILURE );
                    }
                    rep = answer[0] ;
                    if ( ( rep >= 'a' ) && ( rep <= 'z' ) )
                        rep -= 0x20;
                }
                while ( ( rep != 'Y' ) && ( rep != 'N' ) && ( rep != 'A' ) );
            }

            if ( rep == 'N' )
                skip = 1;

            if ( rep == 'A' )
                *popt_overwrite = 1;
        }

        if ( ( skip == 0 ) && ( err == UNZ_OK ) )
        {
            fout = fopen( write_filename, "wb" );

            /* some zipfile don't contain directory alone before file */
            if ( ( fout == NULL ) && ( ( *popt_extract_without_path ) == 0 ) &&
                    ( filename_withoutpath != ( char* )filename_inzip ) )
            {
                char c = *( filename_withoutpath - 1 );
                *( filename_withoutpath - 1 ) = '\0';

                // Fix the path, this will fail if the directoryname is the same as the first filename in the zip
                char *path = ( char * ) malloc( strlen( write_filename ) );
                strcpy( path, write_filename );
                char *ptr = strstr( path, filename_withoutpath );
                *ptr = '\0';
                makedir( path );
                free( path );

                *( filename_withoutpath - 1 ) = c;
                fout = fopen( write_filename, "wb" );
            }

            if ( fout == NULL )
            {
//                printf("error opening %s\n",write_filename);
            }
        }

        if ( fout != NULL )
        {
//            printf(" extracting: %s\n",write_filename);

            do
            {
                err = unzReadCurrentFile( uf, buf, size_buf );
                if ( err < 0 )
                {
//                    printf("error %d with zipfile in unzReadCurrentFile\n",err);
                    break;
                }
                if ( err > 0 )
                    if ( fwrite( buf, err, 1, fout ) != 1 )
                    {
//                        printf("error in writing extracted file\n");
                        err = UNZ_ERRNO;
                        break;
                    }
            }
            while ( err > 0 );
            if ( fout )
                fclose( fout );

        }

        if ( err == UNZ_OK )
        {
            err = unzCloseCurrentFile ( uf );
            if ( err != UNZ_OK )
            {
//                printf("error %d with zipfile in unzCloseCurrentFile\n",err);
            }
        }
        else
            unzCloseCurrentFile( uf ); /* don't lose the error */
    }
    free( filename_withpath );
    free( buf );
    return err;
}


int extractZip( unzFile uf, int opt_extract_without_path, int opt_overwrite, const char* password, const char *basedir )
{
    uLong i;
    unz_global_info gi;
    int err;

    err = unzGetGlobalInfo ( uf, &gi );
    if ( err != UNZ_OK )
//        printf("error %d with zipfile in unzGetGlobalInfo \n",err);

        for ( i = 0; i < gi.number_entry; i++ )
        {
            if ( do_extract_currentfile( uf, &opt_extract_without_path,
                                         &opt_overwrite,
                                         password, basedir ) != UNZ_OK )
                break;

            if ( ( i + 1 ) < gi.number_entry )
            {
                err = unzGoToNextFile( uf );
                if ( err != UNZ_OK )
                {
//                printf("error %d with zipfile in unzGoToNextFile\n",err);
                    break;
                }
            }
        }

    return 0;
}

int extractZipOnefile( unzFile uf, const char* filename, int opt_extract_without_path, int opt_overwrite, const char* password )
{
    if ( unzLocateFile( uf, filename, CASESENSITIVITY ) != UNZ_OK )
    {
//        printf("file %s not found in the zipfile\n",filename);
        return 2;
    }

    if ( do_extract_currentfile( uf, &opt_extract_without_path,
                                 &opt_overwrite,
                                 password, NULL ) == UNZ_OK )
        return 0;
    else
        return 1;
}