util/src/minizip/archive_extract.c - axis-axis2-c-core - Git at Google


 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <axutil_dir_handler.h>
 #include <platforms/axutil_platform_auto_sense.h>
 #include <axutil_string.h>
 #include <zlib.h>
 #include <fcntl.h>
 #include <axis2_unzip.h>
 #include <axis2_crypt.h>
 #include <axis2_ioapi.h>

 #ifdef WIN32
 #include <axis2_iowin32.h>
 #endif

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

 axis2_status_t aar_select(
     );
 int aar_extract(
     axis2_char_t * d_name);

 extern int AXIS2_ALPHASORT(
     );

 int
 axis2_mkdir(const axis2_char_t *
     dir_name)
 {
     int value = 0;
     value = AXIS2_MKDIR(dir_name, 0775);
     return value;
 }

 int
 axis2_create_dir(
     axis2_char_t *new_dir)
 {
     axis2_char_t *buffer;
     axis2_char_t *p;
     axis2_bool_t loop_state = AXIS2_TRUE;
     int len = (int) strlen(new_dir);

     if (len <= 0)
         return 0;

     buffer = (axis2_char_t *) malloc(len + 1);
     strcpy(buffer, new_dir);

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

     if (axis2_mkdir(buffer) == 0)
     {
         free(buffer);
         return 1;
     }

     p = buffer + 1;
     while (loop_state)
     {
         axis2_char_t hold;

         while (*p && *p != '\\' && *p != '/')
             p++;
         hold = *p;
         *p = 0;
         if ((axis2_mkdir(buffer) == -1))
         {
             free(buffer);
             return 0;
         }
         if (hold == 0)
             break;
         *p++ = hold;
     }
     free(buffer);
     return 1;
 }

 int
 axis2_extract_currentfile(
     unzFile uf,
     const int *popt_extract_without_path,
     int *popt_overwrite,
     const axis2_char_t *password)
 {
     axis2_char_t filename_inzip[256];
     axis2_char_t *filename_withoutpath;
     axis2_char_t *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)
     {
         return err;
     }

     size_buf = WRITEBUFFERSIZE;
     buf = (void *) malloc(size_buf);
     if (buf == NULL)
         return UNZ_INTERNALERROR;

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

     if ((*filename_withoutpath) == '\0')
     {
         if ((*popt_extract_without_path) == 0)
         {
             axis2_mkdir(filename_inzip);
         }
     }
     else
     {
         axis2_char_t *write_filename;
         int skip = 0;

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

         err = unzOpenCurrentFilePassword(uf, password);

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

             if ((fout == NULL) && ((*popt_extract_without_path) == 0) &&
                 (filename_withoutpath != (axis2_char_t *) filename_inzip))
             {
                 axis2_char_t c = *(filename_withoutpath - 1);
                 *(filename_withoutpath - 1) = '\0';
                 axis2_create_dir(write_filename);
                 *(filename_withoutpath - 1) = c;
                 fout = fopen(write_filename, "wb");
             }

         }

         if (fout)
         {
             do
             {
                 err = unzReadCurrentFile(uf, buf, size_buf);
                 if (err < 0)
                 {
                     break;
                 }
                 if (err > 0)
                     if (fwrite(buf, err, 1, fout) != 1)
                     {
                         err = UNZ_ERRNO;
                         break;
                     }
             }
             while (err > 0);
             if (fout)
                 fclose(fout);
         }

         if (err == UNZ_OK)
         {
             err = unzCloseCurrentFile(uf);
         }
         else
             unzCloseCurrentFile(uf);
     }

     free(buf);
     return err;
 }

 int
 axis2_extract(
     unzFile uf,
     int opt_extract_without_path,
     int opt_overwrite,
     const axis2_char_t *password)
 {
     uLong i;
     unz_global_info gi;
     int err;

     err = unzGetGlobalInfo(uf, &gi);
     if (err != UNZ_OK)
         return -1;

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

         if ((i + 1) < gi.number_entry)
         {
             err = unzGoToNextFile(uf);
             if (err != UNZ_OK)
             {
                 return -1;
                 break;
             }
         }
     }

     return 0;
 }

 int
 aar_extract(
     axis2_char_t * d_name)
 {
     const axis2_char_t *zipfilename = NULL;
     const axis2_char_t *filename_to_extract = NULL;
     const axis2_char_t *password = NULL;
     axis2_char_t filename_try[MAXFILENAME + 16] = "";
     int opt_do_extract_withoutpath = 0;
     int opt_overwrite = 0;
     int opt_extractdir = 0;
     const axis2_char_t *dir_name = NULL;
     int ret = 0;
     unzFile uf = NULL;

     if (zipfilename == NULL)
         zipfilename = d_name;

     filename_to_extract = d_name;

     if (zipfilename)
     {
         zlib_filefunc_def ffunc;
         strncpy(filename_try, zipfilename, MAXFILENAME - 1);
         filename_try[MAXFILENAME] = '\0';

         axis2_fill_win32_filefunc(&ffunc);
         ((void)(ffunc)); /* Just to avoid unused variable warning */
         AXIS2_UNZOPEN2(zipfilename, ffunc, uf);

         if (uf == NULL)
         {
             strcat(filename_try, ".zip");
             AXIS2_UNZOPEN2(zipfilename, ffunc, uf);
         }
     }

     if (uf == NULL)
         return -1;

     if (opt_extractdir && AXIS2_CHDIR(dir_name))
         exit(-1);

     ret = axis2_extract(uf, opt_do_extract_withoutpath, opt_overwrite,
                          password);
     /*unzCloseCurrentFile(uf);*/
     return ret;
 }

 int
 axis2_extract_onefile(
     unzFile uf,
     const axis2_char_t *filename,
     int opt_extract_without_path,
     int opt_overwrite,
     const axis2_char_t *password)
 {
     if (unzLocateFile(uf, filename, CASESENSITIVITY) != UNZ_OK)
         return -1;

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

 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_archive_extract(
     )
 {
     struct dirent **namelist;
     int n,
      i;
     axis2_char_t *ptr;

 #ifdef WIN32
 	n = axis2_scandir(".", &namelist, 0, alphasort);
 #else
 	n = scandir(".", &namelist, 0, alphasort);
 #endif

 	if (n < 0)
         return AXIS2_FALSE;
     else
     {
         while (n--)
         {
             if ((strcmp(namelist[n]->d_name, ".") == 0) ||
                 (strcmp(namelist[n]->d_name, "..") == 0))
             {
                 for (i = n; i >= 0; i--)    /* clean remaining memory before return */
                     free(namelist[i]);
                 free(namelist);
                 return (AXIS2_FALSE);
             }

             ptr = axutil_rindex(namelist[n]->d_name, '.');
             if ((ptr) &&
                 (((strcmp(ptr, AXIS2_AAR_SUFFIX) == 0)) ||
                  (strcmp(ptr, AXIS2_MAR_SUFFIX) == 0)))
                 for (i = 0; i < n; i++)
                     if (strncmp
                         (namelist[n]->d_name, namelist[i]->d_name,
                          strlen(namelist[i]->d_name)) == 0)
                     {
                         int j;
                         for (j = n; j >= 0; j--)    /* clean remaining memory before return */
                             free(namelist[j]);
                         free(namelist);
                         return (AXIS2_FALSE);
                     }

             aar_extract(namelist[n]->d_name);
             free(namelist[n]);
         }
         free(namelist);
     }
     return (AXIS2_TRUE);
 }

	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <axutil_dir_handler.h>
	#include <platforms/axutil_platform_auto_sense.h>
	#include <axutil_string.h>
	#include <zlib.h>
	#include <fcntl.h>
	#include <axis2_unzip.h>
	#include <axis2_crypt.h>
	#include <axis2_ioapi.h>

	#ifdef WIN32
	#include <axis2_iowin32.h>
	#endif

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

	axis2_status_t aar_select(
	);
	int aar_extract(
	axis2_char_t * d_name);

	extern int AXIS2_ALPHASORT(
	);

	int
	axis2_mkdir(const axis2_char_t *
	dir_name)
	{
	int value = 0;
	value = AXIS2_MKDIR(dir_name, 0775);
	return value;
	}

	int
	axis2_create_dir(
	axis2_char_t *new_dir)
	{
	axis2_char_t *buffer;
	axis2_char_t *p;
	axis2_bool_t loop_state = AXIS2_TRUE;
	int len = (int) strlen(new_dir);

	if (len <= 0)
	return 0;

	buffer = (axis2_char_t *) malloc(len + 1);
	strcpy(buffer, new_dir);

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

	if (axis2_mkdir(buffer) == 0)
	{
	free(buffer);
	return 1;
	}

	p = buffer + 1;
	while (loop_state)
	{
	axis2_char_t hold;

	while (p && p != '\\' && *p != '/')
	p++;
	hold = *p;
	*p = 0;
	if ((axis2_mkdir(buffer) == -1))
	{
	free(buffer);
	return 0;
	}
	if (hold == 0)
	break;
	*p++ = hold;
	}
	free(buffer);
	return 1;
	}

	int
	axis2_extract_currentfile(
	unzFile uf,
	const int *popt_extract_without_path,
	int *popt_overwrite,
	const axis2_char_t *password)
	{
	axis2_char_t filename_inzip[256];
	axis2_char_t *filename_withoutpath;
	axis2_char_t *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)
	{
	return err;
	}

	size_buf = WRITEBUFFERSIZE;
	buf = (void *) malloc(size_buf);
	if (buf == NULL)
	return UNZ_INTERNALERROR;

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

	if ((*filename_withoutpath) == '\0')
	{
	if ((*popt_extract_without_path) == 0)
	{
	axis2_mkdir(filename_inzip);
	}
	}
	else
	{
	axis2_char_t *write_filename;
	int skip = 0;

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

	err = unzOpenCurrentFilePassword(uf, password);

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

	if ((fout == NULL) && ((*popt_extract_without_path) == 0) &&
	(filename_withoutpath != (axis2_char_t *) filename_inzip))
	{
	axis2_char_t c = *(filename_withoutpath - 1);
	*(filename_withoutpath - 1) = '\0';
	axis2_create_dir(write_filename);
	*(filename_withoutpath - 1) = c;
	fout = fopen(write_filename, "wb");
	}

	}

	if (fout)
	{
	do
	{
	err = unzReadCurrentFile(uf, buf, size_buf);
	if (err < 0)
	{
	break;
	}
	if (err > 0)
	if (fwrite(buf, err, 1, fout) != 1)
	{
	err = UNZ_ERRNO;
	break;
	}
	}
	while (err > 0);
	if (fout)
	fclose(fout);
	}

	if (err == UNZ_OK)
	{
	err = unzCloseCurrentFile(uf);
	}
	else
	unzCloseCurrentFile(uf);
	}

	free(buf);
	return err;
	}

	int
	axis2_extract(
	unzFile uf,
	int opt_extract_without_path,
	int opt_overwrite,
	const axis2_char_t *password)
	{
	uLong i;
	unz_global_info gi;
	int err;

	err = unzGetGlobalInfo(uf, &gi);
	if (err != UNZ_OK)
	return -1;

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

	if ((i + 1) < gi.number_entry)
	{
	err = unzGoToNextFile(uf);
	if (err != UNZ_OK)
	{
	return -1;
	break;
	}
	}
	}

	return 0;
	}

	int
	aar_extract(
	axis2_char_t * d_name)
	{
	const axis2_char_t *zipfilename = NULL;
	const axis2_char_t *filename_to_extract = NULL;
	const axis2_char_t *password = NULL;
	axis2_char_t filename_try[MAXFILENAME + 16] = "";
	int opt_do_extract_withoutpath = 0;
	int opt_overwrite = 0;
	int opt_extractdir = 0;
	const axis2_char_t *dir_name = NULL;
	int ret = 0;
	unzFile uf = NULL;

	if (zipfilename == NULL)
	zipfilename = d_name;

	filename_to_extract = d_name;

	if (zipfilename)
	{
	zlib_filefunc_def ffunc;
	strncpy(filename_try, zipfilename, MAXFILENAME - 1);
	filename_try[MAXFILENAME] = '\0';

	axis2_fill_win32_filefunc(&ffunc);
	((void)(ffunc)); /* Just to avoid unused variable warning */
	AXIS2_UNZOPEN2(zipfilename, ffunc, uf);

	if (uf == NULL)
	{
	strcat(filename_try, ".zip");
	AXIS2_UNZOPEN2(zipfilename, ffunc, uf);
	}
	}

	if (uf == NULL)
	return -1;

	if (opt_extractdir && AXIS2_CHDIR(dir_name))
	exit(-1);

	ret = axis2_extract(uf, opt_do_extract_withoutpath, opt_overwrite,
	password);
	/unzCloseCurrentFile(uf);/
	return ret;
	}

	int
	axis2_extract_onefile(
	unzFile uf,
	const axis2_char_t *filename,
	int opt_extract_without_path,
	int opt_overwrite,
	const axis2_char_t *password)
	{
	if (unzLocateFile(uf, filename, CASESENSITIVITY) != UNZ_OK)
	return -1;

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

	AXIS2_EXTERN axis2_status_t AXIS2_CALL
	axis2_archive_extract(
	)
	{
	struct dirent **namelist;
	int n,
	i;
	axis2_char_t *ptr;

	#ifdef WIN32
	n = axis2_scandir(".", &namelist, 0, alphasort);
	#else
	n = scandir(".", &namelist, 0, alphasort);
	#endif

	if (n < 0)
	return AXIS2_FALSE;
	else
	{
	while (n--)
	{
	if ((strcmp(namelist[n]->d_name, ".") == 0) \|\|
	(strcmp(namelist[n]->d_name, "..") == 0))
	{
	for (i = n; i >= 0; i--) /* clean remaining memory before return */
	free(namelist[i]);
	free(namelist);
	return (AXIS2_FALSE);
	}

	ptr = axutil_rindex(namelist[n]->d_name, '.');
	if ((ptr) &&
	(((strcmp(ptr, AXIS2_AAR_SUFFIX) == 0)) \|\|
	(strcmp(ptr, AXIS2_MAR_SUFFIX) == 0)))
	for (i = 0; i < n; i++)
	if (strncmp
	(namelist[n]->d_name, namelist[i]->d_name,
	strlen(namelist[i]->d_name)) == 0)
	{
	int j;
	for (j = n; j >= 0; j--) /* clean remaining memory before return */
	free(namelist[j]);
	free(namelist);
	return (AXIS2_FALSE);
	}

	aar_extract(namelist[n]->d_name);
	free(namelist[n]);
	}
	free(namelist);
	}
	return (AXIS2_TRUE);
	}