emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reorganise unarchiving functions, more code re-use, only does single pass(no more linked lists), basis for supporting a cpio (and cheaper untar) applet, but cpio applet isnt included in this.

Browse Source 
It effects ar, dpkg-deb applets only
This commit is contained in:
Glenn L McGrath 2001-06-20 07:48:00 +00:00
parent b4a26e6fc0
commit eb1c94078f
16 changed files with 585 additions and 704 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Makefile
View File

@ -236,19 +236,17 @@ endif
LIBBB = libbb
LIBBB_LIB = libbb.a
LIBBB_CSRC= append_archive_list.c add_from_archive_list.c ask_confirmation.c \
chomp.c concat_path_file.c copy_file.c copy_file_chunk.c create_path.c \
daemon.c deb_extract.c device_open.c error_msg.c error_msg_and_die.c \
extract_archive.c fgets_str.c find_mount_point.c find_pid_by_name.c \
find_root_device.c full_read.c full_write.c get_ar_headers.c get_console.c \
get_last_path_component.c get_line_from_file.c get_tar_headers.c \
get_tar_gz_headers.c gz_open.c human_readable.c isdirectory.c kernel_version.c \
loop.c mode_string.c module_syscalls.c mtab.c mtab_file.c my_getgrnam.c \
my_getgrgid.c my_getpwnam.c my_getpwnamegid.c my_getpwuid.c parse_mode.c \
parse_number.c perror_msg.c perror_msg_and_die.c print_file.c \
process_escape_sequence.c read_package_field.c recursive_action.c safe_read.c \
safe_strncpy.c syscalls.c syslog_msg_with_name.c time_string.c \
trim.c unzip.c vdprintf.c verror_msg.c vperror_msg.c wfopen.c xfuncs.c \
LIBBB_CSRC= ask_confirmation.c chomp.c concat_path_file.c copy_file.c \
copy_file_chunk.c create_path.c daemon.c device_open.c error_msg.c \
error_msg_and_die.c fgets_str.c find_mount_point.c find_pid_by_name.c \
find_root_device.c full_read.c full_write.c get_console.c \
get_last_path_component.c get_line_from_file.c gz_open.c human_readable.c \
isdirectory.c kernel_version.c loop.c mode_string.c module_syscalls.c mtab.c \
mtab_file.c my_getgrnam.c my_getgrgid.c my_getpwnam.c my_getpwnamegid.c \
my_getpwuid.c parse_mode.c parse_number.c perror_msg.c perror_msg_and_die.c \
print_file.c process_escape_sequence.c read_package_field.c recursive_action.c \
safe_read.c safe_strncpy.c syscalls.c syslog_msg_with_name.c time_string.c \
trim.c unarchive.c unzip.c vdprintf.c verror_msg.c vperror_msg.c wfopen.c xfuncs.c \
xgetcwd.c xreadlink.c xregcomp.c interface.c remove_file.c last_char_is.c \
copyfd.c vherror_msg.c herror_msg.c herror_msg_and_die.c xgethostbyname.c
LIBBB_OBJS=$(patsubst %.c,$(LIBBB)/%.o, $(LIBBB_CSRC))

44
ar.c
View File

@ -24,6 +24,7 @@
*/
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <unistd.h>
#include "busybox.h"
@ -31,9 +32,12 @@
extern int ar_main(int argc, char **argv)
{
FILE *src_stream = NULL;
int extract_function = 0, opt = 0;
file_headers_t *head;
file_headers_t *ar_extract_list = NULL;
char **extract_names = NULL;
char ar_magic[8];
int extract_function = 0;
int opt;
int num_of_entries = 0;
extern off_t archive_offset;
while ((opt = getopt(argc, argv, "ovtpx")) != -1) {
switch (opt) {
@ -63,27 +67,23 @@ extern int ar_main(int argc, char **argv)
}
src_stream = xfopen(argv[optind++], "r");
head = get_ar_headers(src_stream);
/* find files to extract or display */
/* search through argv and build extract list */
ar_extract_list = (file_headers_t *) xcalloc(1, sizeof(file_headers_t));
if (optind < argc) {
while (optind < argc) {
ar_extract_list = add_from_archive_list(head, ar_extract_list, argv[optind]);
optind++;
}
} else {
ar_extract_list = head;
/* check ar magic */
fread(ar_magic, 1, 8, src_stream);
if (strncmp(ar_magic,"!<arch>",7) != 0) {
error_msg_and_die("invalid magic");
}
archive_offset = 8;
extract_names = malloc(sizeof(char *));
extract_names[0] = NULL;
while (optind < argc) {
num_of_entries++;
*extract_names = realloc(*extract_names, num_of_entries);
extract_names[num_of_entries - 1] = xstrdup(argv[optind]);
optind++;
}
/* If there isnt even one possible entry then abort */
if (ar_extract_list->name == NULL) {
error_msg_and_die("No files to extract");
}
fseek(src_stream, 0, SEEK_SET);
extract_archive(src_stream, stdout, ar_extract_list, extract_function, "./");
unarchive(src_stream, &get_header_ar, extract_function, "./", extract_names);
return EXIT_SUCCESS;
}

44
archival/ar.c
View File

@ -24,6 +24,7 @@
*/
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <unistd.h>
#include "busybox.h"
@ -31,9 +32,12 @@
extern int ar_main(int argc, char **argv)
{
FILE *src_stream = NULL;
int extract_function = 0, opt = 0;
file_headers_t *head;
file_headers_t *ar_extract_list = NULL;
char **extract_names = NULL;
char ar_magic[8];
int extract_function = 0;
int opt;
int num_of_entries = 0;
extern off_t archive_offset;
while ((opt = getopt(argc, argv, "ovtpx")) != -1) {
switch (opt) {
@ -63,27 +67,23 @@ extern int ar_main(int argc, char **argv)
}
src_stream = xfopen(argv[optind++], "r");
head = get_ar_headers(src_stream);
/* find files to extract or display */
/* search through argv and build extract list */
ar_extract_list = (file_headers_t *) xcalloc(1, sizeof(file_headers_t));
if (optind < argc) {
while (optind < argc) {
ar_extract_list = add_from_archive_list(head, ar_extract_list, argv[optind]);
optind++;
}
} else {
ar_extract_list = head;
/* check ar magic */
fread(ar_magic, 1, 8, src_stream);
if (strncmp(ar_magic,"!<arch>",7) != 0) {
error_msg_and_die("invalid magic");
}
archive_offset = 8;
extract_names = malloc(sizeof(char *));
extract_names[0] = NULL;
while (optind < argc) {
num_of_entries++;
*extract_names = realloc(*extract_names, num_of_entries);
extract_names[num_of_entries - 1] = xstrdup(argv[optind]);
optind++;
}
/* If there isnt even one possible entry then abort */
if (ar_extract_list->name == NULL) {
error_msg_and_die("No files to extract");
}
fseek(src_stream, 0, SEEK_SET);
extract_archive(src_stream, stdout, ar_extract_list, extract_function, "./");
unarchive(src_stream, &get_header_ar, extract_function, "./", extract_names);
return EXIT_SUCCESS;
}

2
archival/dpkg_deb.c
View File

@ -26,7 +26,7 @@ extern int dpkg_deb_main(int argc, char **argv)
char *output_buffer = NULL;
int opt = 0;
int arg_type = 0;
int deb_extract_funct = 0;
int deb_extract_funct = extract_create_dirs;
const int arg_type_prefix = 1;
const int arg_type_field = 2;

2
dpkg_deb.c
View File

@ -26,7 +26,7 @@ extern int dpkg_deb_main(int argc, char **argv)
char *output_buffer = NULL;
int opt = 0;
int arg_type = 0;
int deb_extract_funct = 0;
int deb_extract_funct = extract_create_dirs;
const int arg_type_prefix = 1;
const int arg_type_field = 2;

32
include/libbb.h
View File

@ -213,23 +213,9 @@ char *xreadlink(const char *path);
char *concat_path_file(const char *path, const char *filename);
char *last_char_is(const char *s, int c);
typedef struct file_headers_s {
char *name;
char *link_name;
off_t size;
uid_t uid;
gid_t gid;
mode_t mode;
time_t mtime;
off_t offset;
dev_t device;
struct file_headers_s *next;
} file_headers_t;
file_headers_t *get_ar_headers(FILE *in_file);
file_headers_t *get_tar_headers(FILE *tar_stream);
file_headers_t *get_tar_gz_headers(FILE *compressed_stream);
file_headers_t *append_archive_list(file_headers_t *head, file_headers_t *tail_entry);
file_headers_t *add_from_archive_list(file_headers_t *master_list, file_headers_t *new_list, const char *name);
void *get_header_ar(FILE *in_file);
void *get_header_cpio(FILE *src_stream);
void *get_header_tar(FILE *tar_stream);
enum extract_functions_e {
extract_verbose_list = 1,
@ -240,18 +226,20 @@ enum extract_functions_e {
extract_preserve_date = 32,
extract_data_tar_gz = 64,
extract_control_tar_gz = 128,
extract_unzip_only = 256
extract_unzip_only = 256,
extract_unconditional = 512,
extract_create_dirs = 1024
};
char *extract_archive(FILE *src_stream, FILE *out_stream, file_headers_t *extract_headers, int function, const char *prefix);
char *deb_extract(const char *package_filename, FILE *out_stream, const int function,
char *unarchive(FILE *src_stream, void *(*get_header)(FILE *),
const int extract_function, const char *prefix, char **extract_names);
char *deb_extract(const char *package_filename, FILE *out_stream, const int extract_function,
const char *prefix, const char *filename);
char *read_package_field(const char *package_buffer);
int seek_sub_file(FILE *in_file, file_headers_t *headers, const char *tar_gz_file);
char *fgets_str(FILE *file, const char *terminating_string);
extern int unzip(FILE *l_in_file, FILE *l_out_file);
extern void gz_close(int gunzip_pid);
extern int gz_open(FILE *compressed_file, int *pid);
extern FILE *gz_open(FILE *compressed_file, int *pid);
extern struct hostent *xgethostbyname(const char *name);

31
libbb/add_from_archive_list.c
View File

@ -1,31 +0,0 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "libbb.h"
file_headers_t *add_from_archive_list(file_headers_t *master_list, file_headers_t *new_list, const char *filename)
{
file_headers_t *list_ptr;
list_ptr = master_list;
while (list_ptr != NULL) {
if (strcmp(filename, list_ptr->name) == 0) {
return(append_archive_list(new_list, list_ptr));
}
list_ptr = list_ptr->next;
}
return(NULL);
}

39
libbb/append_archive_list.c
View File

@ -1,39 +0,0 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdlib.h>
#include "libbb.h"
file_headers_t *append_archive_list(file_headers_t *head, file_headers_t *tail_entry)
{
file_headers_t *tail_ptr;
file_headers_t *new_node = (file_headers_t *) malloc(sizeof(file_headers_t));
*new_node = *tail_entry;
new_node->next = NULL;
if (head->name == NULL) {
head = new_node;
} else {
tail_ptr = head;
while(tail_ptr->next != NULL) {
tail_ptr = tail_ptr->next;
}
tail_ptr->next = new_node;
}
return(head);
}

124
libbb/deb_extract.c
View File

@ -1,124 +0,0 @@
/* vi: set sw=4 ts=4: */
/*
* Copyright (C) tons of folks. Tracking down who wrote what
* isn't something I'm going to worry about... If you wrote something
* here, please feel free to acknowledge your work.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Based in part on code from sash, Copyright (c) 1999 by David I. Bell
* Permission has been granted to redistribute this code under the GPL.
*
*/
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "libbb.h"
int seek_sub_file(FILE *in_file, file_headers_t *headers, const char *tar_gz_file)
{
/* find the headers for the specified .tar.gz file */
while (headers != NULL) {
if (strcmp(headers->name, tar_gz_file) == 0) {
fseek(in_file, headers->offset, SEEK_SET);
return(EXIT_SUCCESS);
}
headers = headers->next;
}
return(EXIT_FAILURE);
}
/*
* The contents of argument depend on the value of function.
* It is either a dir name or a control file or field name(see dpkg_deb.c)
*/
char *deb_extract(const char *package_filename, FILE *out_stream, const int extract_function,
const char *prefix, const char *filename)
{
FILE *deb_stream, *uncompressed_stream;
file_headers_t *ar_headers = NULL;
file_headers_t *tar_headers = NULL;
file_headers_t *list_ptr;
file_headers_t *deb_extract_list = (file_headers_t *) calloc(1, sizeof(file_headers_t));
char *ared_file = NULL;
char *output_buffer = NULL;
int gunzip_pid;
if (extract_function & extract_control_tar_gz) {
ared_file = xstrdup("control.tar.gz");
}
else if (extract_function & extract_data_tar_gz) {
ared_file = xstrdup("data.tar.gz");
}
/* open the debian package to be worked on */
deb_stream = wfopen(package_filename, "r");
ar_headers = (file_headers_t *) xmalloc(sizeof(file_headers_t));
/* get a linked list of all ar entries */
ar_headers = get_ar_headers(deb_stream);
if (ar_headers == NULL) {
error_msg("Couldnt get ar headers\n");
return(NULL);
}
/* seek to the start of the .tar.gz file within the ar file*/
fseek(deb_stream, 0, SEEK_SET);
if (seek_sub_file(deb_stream, ar_headers, ared_file) == EXIT_FAILURE) {
error_msg("Couldnt seek to file %s", ared_file);
}
/* get a linked list of all tar entries */
tar_headers = get_tar_gz_headers(deb_stream);
if (tar_headers == NULL) {
error_msg("Couldnt get tar headers\n");
return(NULL);
}
if (extract_function & extract_one_to_buffer) {
list_ptr = tar_headers;
while (list_ptr != NULL) {
if (strcmp(filename, list_ptr->name) == 0) {
deb_extract_list = append_archive_list(deb_extract_list, list_ptr);
break;
}
list_ptr = list_ptr->next;
}
} else {
deb_extract_list = tar_headers;
}
/* seek to the start of the .tar.gz file within the ar file*/
if (seek_sub_file(deb_stream, ar_headers, ared_file) == EXIT_FAILURE) {
error_msg("Couldnt seek to ar file");
}
/* open a stream of decompressed data */
uncompressed_stream = fdopen(gz_open(deb_stream, &gunzip_pid), "r");
output_buffer = extract_archive(uncompressed_stream, out_stream, deb_extract_list, extract_function, prefix);
gz_close(gunzip_pid);
fclose(deb_stream);
fclose(uncompressed_stream);
free(ared_file);
return(output_buffer);
}

132
libbb/extract_archive.c
View File

@ -1,132 +0,0 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <utime.h>
#include "libbb.h"
/* Extract files in the linear linked list 'extract_headers' to either
* filesystem, stdout or buffer depending on the value of 'function' which is
* described in extract_files.h
*
* prefix doesnt have to be just a directory, it may prefix the filename as well.
*
* e.g. '/var/lib/dpkg/info/dpkg.' will extract all files to the base bath
* '/var/lib/dpkg/info/' and all files/dirs created in that dir will have
* 'dpkg.' as their prefix
*
* For this reason if prefix does point to a dir then it must end with a
* trailing '/' or else the last dir will be assumed to be the file prefix
*/
char *extract_archive(FILE *src_stream, FILE *out_stream, file_headers_t *extract_headers, int function, const char *prefix)
{
FILE *dst_stream = NULL;
char *full_name = NULL;
char *buffer = NULL;
size_t uncompressed_count = 0;
struct utimbuf t;
/* find files to extract or display */
while (extract_headers != NULL) {
/* prefix doesnt have to be a proper path it may prepend
* the filename as well */
if (prefix != NULL) {
/* strip leading '/' in filename to extract as prefix may not be dir */
char *tmp_str = strchr(extract_headers->name, '/');
if (tmp_str == NULL) {
tmp_str = extract_headers->name;
} else {
tmp_str++;
}
/* Cant use concat_path_file here as prefix might not be a directory */
full_name = xmalloc(strlen(prefix) + strlen(tmp_str) + 1);
strcpy(full_name, prefix);
strcat(full_name, tmp_str);
} else {
full_name = extract_headers->name;
}
/* Seek to start of file, have to use fgetc as src_stream may be a pipe
* you cant [lf]seek on pipes */
while (uncompressed_count < extract_headers->offset) {
fgetc(src_stream);
uncompressed_count++;
}
if (S_ISREG(extract_headers->mode)) {
if (function & extract_to_stdout) {
copy_file_chunk(src_stream, out_stream, extract_headers->size);
uncompressed_count += extract_headers->size;
}
else if (function & extract_all_to_fs) {
dst_stream = wfopen(full_name, "w");
copy_file_chunk(src_stream, dst_stream, extract_headers->size);
uncompressed_count += extract_headers->size;
fclose(dst_stream);
}
else if (function & extract_one_to_buffer) {
buffer = (char *) xmalloc(extract_headers->size + 1);
fread(buffer, 1, extract_headers->size, src_stream);
break;
}
}
#if defined BB_DPKG | defined BB_DPKG_DEB
else if (S_ISDIR(extract_headers->mode)) {
if (function & extract_all_to_fs) {
if (create_path(full_name, extract_headers->mode) == FALSE) {
perror_msg("Cannot mkdir %s", extract_headers->name);
return NULL;
}
}
}
else if (S_ISLNK(extract_headers->mode)) {
if (function & extract_all_to_fs) {
if (symlink(extract_headers->link_name, full_name) < 0) {
perror_msg("Cannot create hard link from %s to '%s'", extract_headers->name, extract_headers->link_name);
return NULL;
}
}
}
#endif
if (function & extract_verbose_list) {
fprintf(out_stream, "%s %d/%d %8d %s ", mode_string(extract_headers->mode),
extract_headers->uid, extract_headers->gid,
(int) extract_headers->size, time_string(extract_headers->mtime));
}
if ((function & extract_list) || (function & extract_verbose_list)){
/* fputs doesnt add a trailing \n, so use fprintf */
fprintf(out_stream, "%s\n", extract_headers->name);
}
if (function & extract_preserve_date) {
t.actime = extract_headers->mtime;
t.modtime = extract_headers->mtime;
utime(full_name, &t);
}
chmod(full_name, extract_headers->mode);
free(full_name);
extract_headers = extract_headers->next;
}
return(buffer);
}

119
libbb/get_ar_headers.c
View File

@ -1,119 +0,0 @@
/* vi: set sw=4 ts=4: */
/*
* Utility routines.
*
* Copyright (C) tons of folks. Tracking down who wrote what
* isn't something I'm going to worry about... If you wrote something
* here, please feel free to acknowledge your work.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Based in part on code from sash, Copyright (c) 1999 by David I. Bell
* Permission has been granted to redistribute this code under the GPL.
*
*/
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "libbb.h"
file_headers_t *get_ar_headers(FILE *in_file)
{
typedef struct raw_ar_header_s { /* Byte Offset */
char name[16]; /* 0-15 */
char date[12]; /* 16-27 */
char uid[6];
char gid[6]; /* 28-39 */
char mode[8]; /* 40-47 */
char size[10]; /* 48-57 */
char fmag[2]; /* 58-59 */
} raw_ar_header_t;
raw_ar_header_t raw_ar_header;
file_headers_t *ar_list, *ar_entry;
char ar_magic[8];
char *long_name=NULL;
/* check ar magic */
if (fread(ar_magic, 1, 8, in_file) != 8) {
error_msg("cannot read magic");
return(NULL);
}
if (strncmp(ar_magic,"!<arch>",7) != 0) {
error_msg("invalid magic");
return(NULL);
}
ar_list = (file_headers_t *) xcalloc(1, sizeof(file_headers_t));
while (fread((char *) &raw_ar_header, 1, 60, in_file) == 60) {
ar_entry = (file_headers_t *) xcalloc(1, sizeof(file_headers_t));
/* check the end of header markers are valid */
if ((raw_ar_header.fmag[0] != '`') || (raw_ar_header.fmag[1] != '\n')) {
char newline;
if (raw_ar_header.fmag[1] != '`') {
break;
}
/* some version of ar, have an extra '\n' after each entry */
fread(&newline, 1, 1, in_file);
if (newline!='\n') {
break;
}
/* fix up the header, we started reading 1 byte too early due to a '\n' */
memmove((char *) &raw_ar_header, (char *)&raw_ar_header+1, 59);
/* dont worry about adding the last '\n', we dont need it now */
}
ar_entry->size = (size_t) atoi(raw_ar_header.size);
/* long filenames have '/' as the first character */
if (raw_ar_header.name[0] == '/') {
if (raw_ar_header.name[1] == '/') {
/* multiple long filenames are stored as data in one entry */
long_name = (char *) xrealloc(long_name, ar_entry->size);
fread(long_name, 1, ar_entry->size, in_file);
continue;
}
else {
/* The number after the '/' indicates the offset in the ar data section
(saved in variable long_name) that conatains the real filename */
const int long_name_offset = (int) atoi((char *) &raw_ar_header.name[1]);
ar_entry->name = xmalloc(strlen(&long_name[long_name_offset]));
strcpy(ar_entry->name, &long_name[long_name_offset]);
}
}
else {
/* short filenames */
ar_entry->name = xmalloc(16);
ar_entry->name = strncpy(ar_entry->name, raw_ar_header.name, 16);
}
ar_entry->name[strcspn(ar_entry->name, " /")]='\0';
/* convert the rest of the now valid char header to its typed struct */
parse_mode(raw_ar_header.mode, &ar_entry->mode);
ar_entry->mtime = atoi(raw_ar_header.date);
ar_entry->uid = atoi(raw_ar_header.uid);
ar_entry->gid = atoi(raw_ar_header.gid);
ar_entry->offset = ftell(in_file);
ar_entry->next = NULL;
fseek(in_file, (off_t) ar_entry->size, SEEK_CUR);
ar_list = append_archive_list(ar_list, ar_entry);
}
return(ar_list);
}

39
libbb/get_tar_gz_headers.c
View File

@ -1,39 +0,0 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <unistd.h>
#include "libbb.h"
file_headers_t *get_tar_gz_headers(FILE *compressed_stream)
{
FILE *uncompressed_stream;
file_headers_t *tar_headers_tree;
int gunzip_pid;
int gz_fd ;
/* open a stream of decompressed data */
gz_fd = gz_open(compressed_stream, &gunzip_pid);
if (gz_fd == -1) {
error_msg("Couldnt initialise gzip stream");
}
uncompressed_stream = fdopen(gz_fd, "r");
tar_headers_tree = get_tar_headers(uncompressed_stream);
fclose(uncompressed_stream);
close(gz_fd);
gz_close(gunzip_pid);
return(tar_headers_tree);
}

111
libbb/get_tar_headers.c
View File

@ -1,111 +0,0 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "libbb.h"
file_headers_t *get_tar_headers(FILE *tar_stream)
{
typedef struct raw_tar_header {
char name[100]; /* 0-99 */
char mode[8]; /* 100-107 */
char uid[8]; /* 108-115 */
char gid[8]; /* 116-123 */
char size[12]; /* 124-135 */
char mtime[12]; /* 136-147 */
char chksum[8]; /* 148-155 */
char typeflag; /* 156-156 */
char linkname[100]; /* 157-256 */
char magic[6]; /* 257-262 */
char version[2]; /* 263-264 */
char uname[32]; /* 265-296 */
char gname[32]; /* 297-328 */
char devmajor[8]; /* 329-336 */
char devminor[8]; /* 337-344 */
char prefix[155]; /* 345-499 */
char padding[12]; /* 500-512 */
} raw_tar_header_t;
raw_tar_header_t raw_tar_header;
unsigned char *temp = (unsigned char *) &raw_tar_header;
file_headers_t *tar_headers_list = (file_headers_t *) calloc(1, sizeof(file_headers_t));
file_headers_t *tar_entry;
long i;
long next_header_offset = 0;
long current_offset = 0;
while (fread((char *) &raw_tar_header, 1, 512, tar_stream) == 512) {
long sum = 0;
current_offset += 512;
/* Check header has valid magic, unfortunately some tar files
* have empty (0'ed) tar entries at the end, which will
* cause this to fail, so fail silently for now
*/
if (strncmp(raw_tar_header.magic, "ustar", 5) != 0) {
// error_msg("invalid magic, [%s]\n", raw_tar_header.magic);
break;
}
/* Do checksum on headers */
for (i = 0; i < 148 ; i++) {
sum += temp[i];
}
sum += ' ' * 8;
for (i = 156; i < 512 ; i++) {
sum += temp[i];
}
if (sum != strtol(raw_tar_header.chksum, NULL, 8)) {
error_msg("Invalid tar header checksum");
break;
}
/* convert to type'ed variables */
tar_entry = xcalloc(1, sizeof(file_headers_t));
tar_entry->name = xstrdup(raw_tar_header.name);
tar_entry->offset = (off_t) current_offset;
parse_mode(raw_tar_header.mode, &tar_entry->mode);
tar_entry->uid = strtol(raw_tar_header.uid, NULL, 8);
tar_entry->gid = strtol(raw_tar_header.gid, NULL, 8);
tar_entry->size = strtol(raw_tar_header.size, NULL, 8);
tar_entry->mtime = strtol(raw_tar_header.mtime, NULL, 8);
tar_entry->link_name = xstrdup(raw_tar_header.linkname);
// tar_entry->devmajor = strtol(rawHeader->devmajor, NULL, 8);
// tar_entry->devminor = strtol(rawHeader->devminor, NULL, 8);
tar_headers_list = append_archive_list(tar_headers_list, tar_entry);
/* start of next header is at */
next_header_offset = current_offset + tar_entry->size;
if (tar_entry->size % 512 != 0) {
next_header_offset += (512 - tar_entry->size % 512);
}
/*
* Seek to start of next block, cant use fseek as unzip() does support it
*/
while (current_offset < next_header_offset) {
if (fgetc(tar_stream) == EOF) {
break;
}
current_offset++;
}
}
return(tar_headers_list);
}

14
libbb/gz_open.c
View File

@ -6,17 +6,17 @@
#include <unistd.h>
#include "libbb.h"
extern int gz_open(FILE *compressed_file, int *pid)
extern FILE *gz_open(FILE *compressed_file, int *pid)
{
int unzip_pipe[2];
if (pipe(unzip_pipe)!=0) {
error_msg("pipe error");
return(EXIT_FAILURE);
return(NULL);
}
if ((*pid = fork()) == -1) {
error_msg("fork failured");
return(EXIT_FAILURE);
return(NULL);
}
if (*pid==0) {
/* child process */
@ -27,7 +27,9 @@ extern int gz_open(FILE *compressed_file, int *pid)
close(unzip_pipe[1]);
exit(EXIT_SUCCESS);
}
close(unzip_pipe[1]);
return(unzip_pipe[0]);
}
if (unzip_pipe[0] == -1) {
error_msg("Couldnt initialise gzip stream");
}
return(fdopen(unzip_pipe[0], "r"));
}

32
libbb/libbb.h
View File

@ -213,23 +213,9 @@ char *xreadlink(const char *path);
char *concat_path_file(const char *path, const char *filename);
char *last_char_is(const char *s, int c);
typedef struct file_headers_s {
char *name;
char *link_name;
off_t size;
uid_t uid;
gid_t gid;
mode_t mode;
time_t mtime;
off_t offset;
dev_t device;
struct file_headers_s *next;
} file_headers_t;
file_headers_t *get_ar_headers(FILE *in_file);
file_headers_t *get_tar_headers(FILE *tar_stream);
file_headers_t *get_tar_gz_headers(FILE *compressed_stream);
file_headers_t *append_archive_list(file_headers_t *head, file_headers_t *tail_entry);
file_headers_t *add_from_archive_list(file_headers_t *master_list, file_headers_t *new_list, const char *name);
void *get_header_ar(FILE *in_file);
void *get_header_cpio(FILE *src_stream);
void *get_header_tar(FILE *tar_stream);
enum extract_functions_e {
extract_verbose_list = 1,
@ -240,18 +226,20 @@ enum extract_functions_e {
extract_preserve_date = 32,
extract_data_tar_gz = 64,
extract_control_tar_gz = 128,
extract_unzip_only = 256
extract_unzip_only = 256,
extract_unconditional = 512,
extract_create_dirs = 1024
};
char *extract_archive(FILE *src_stream, FILE *out_stream, file_headers_t *extract_headers, int function, const char *prefix);
char *deb_extract(const char *package_filename, FILE *out_stream, const int function,
char *unarchive(FILE *src_stream, void *(*get_header)(FILE *),
const int extract_function, const char *prefix, char **extract_names);
char *deb_extract(const char *package_filename, FILE *out_stream, const int extract_function,
const char *prefix, const char *filename);
char *read_package_field(const char *package_buffer);
int seek_sub_file(FILE *in_file, file_headers_t *headers, const char *tar_gz_file);
char *fgets_str(FILE *file, const char *terminating_string);
extern int unzip(FILE *l_in_file, FILE *l_out_file);
extern void gz_close(int gunzip_pid);
extern int gz_open(FILE *compressed_file, int *pid);
extern FILE *gz_open(FILE *compressed_file, int *pid);
extern struct hostent *xgethostbyname(const char *name);

500
libbb/unarchive.c Normal file
View File

@ -0,0 +1,500 @@
/*
* Copyright (C) 2000 by Glenn McGrath
* Copyright (C) 2001 by Laurence Anderson
*
* Based on previous work by busybox developers and others.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <utime.h>
#include "libbb.h"
typedef struct file_headers_s {
char *name;
char *link_name;
off_t size;
uid_t uid;
gid_t gid;
mode_t mode;
time_t mtime;
dev_t device;
} file_header_t;
off_t archive_offset;
void seek_sub_file(FILE *src_stream, const int count)
{
int i;
/* Try to fseek as faster */
archive_offset += count;
if (fseek(src_stream, count, SEEK_CUR) != 0 && errno == ESPIPE) {
for (i = 0; i < count; i++) {
fgetc(src_stream);
}
}
return;
}
/* Extract the data postioned at src_stream to either filesystem, stdout or
* buffer depending on the value of 'function' which is defined in libbb.h
*
* prefix doesnt have to be just a directory, it may prefix the filename as well.
*
* e.g. '/var/lib/dpkg/info/dpkg.' will extract all files to the base bath
* '/var/lib/dpkg/info/' and all files/dirs created in that dir will have
* 'dpkg.' as their prefix
*
* For this reason if prefix does point to a dir then it must end with a
* trailing '/' or else the last dir will be assumed to be the file prefix
*/
char *extract_archive(FILE *src_stream, FILE *out_stream, const file_header_t *file_entry,
const int function, const char *prefix)
{
FILE *dst_stream = NULL;
char *full_name = NULL;
char *buffer = NULL;
struct utimbuf t;
/* prefix doesnt have to be a proper path it may prepend
* the filename as well */
if (prefix != NULL) {
/* strip leading '/' in filename to extract as prefix may not be dir */
/* Cant use concat_path_file here as prefix might not be a directory */
char *path = file_entry->name;
if (*path == '/') {
path++;
}
full_name = xmalloc(strlen(prefix) + strlen(path) + 1);
strcpy(full_name, prefix);
strcat(full_name, path);
} else {
full_name = file_entry->name;
}
if (function & extract_to_stdout) {
if (S_ISREG(file_entry->mode)) {
copy_file_chunk(src_stream, out_stream, file_entry->size);
archive_offset += file_entry->size;
}
}
else if (function & extract_one_to_buffer) {
if (S_ISREG(file_entry->mode)) {
buffer = (char *) xmalloc(file_entry->size + 1);
fread(buffer, 1, file_entry->size, src_stream);
archive_offset += file_entry->size;
return(buffer);
}
}
else if (function & extract_all_to_fs) {
#if 0
struct stat oldfile;
if ( (S_ISLNK(file_entry->mode) ? lstat (full_name, &oldfile) : stat (full_name, &oldfile)) == 0) { /* The file already exists */
if (function & extract_unconditional || oldfile.st_mtime < file_entry->mtime) {
if (!S_ISDIR(oldfile.st_mode)) {
unlink(full_name); /* Directories might not be empty etc */
}
} else {
error_msg("%s not created: newer or same age file exists", file_entry->name);
if (S_ISREG(file_entry->mode)) {
seek_sub_file(src_stream, file_entry->size);
}
return (NULL);
}
}
#endif
switch(file_entry->mode & S_IFMT) {
case S_IFREG:
if (file_entry->link_name) { /* Found a cpio hard link */
if (link(file_entry->link_name, full_name) != 0) {
perror_msg("Cannot link from %s to '%s'",
file_entry->name, file_entry->link_name);
}
} else {
if ((dst_stream = wfopen(full_name, "w")) == NULL) {
seek_sub_file(src_stream, file_entry->size);
return NULL;
}
archive_offset += file_entry->size;
copy_file_chunk(src_stream, dst_stream, file_entry->size);
fclose(dst_stream);
}
break;
case S_IFDIR:
/* Use create_path instead of mkdir incase prefix path
* hasnt been created */
if (function & extract_create_dirs) {
if (create_path(full_name, file_entry->mode) == FALSE) {
return NULL;
}
}
break;
case S_IFLNK:
if (symlink(file_entry->link_name, full_name) < 0) {
perror_msg("Cannot create symlink from %s to '%s'", file_entry->name, file_entry->link_name);
return NULL;
}
break;
case S_IFSOCK:
case S_IFBLK:
case S_IFCHR:
case S_IFIFO:
if (mknod(full_name, file_entry->mode, file_entry->device) == -1) {
perror_msg("Cannot create node %s", file_entry->name);
return NULL;
}
break;
}
if (function & extract_preserve_date) {
t.actime = file_entry->mtime;
t.modtime = file_entry->mtime;
utime(full_name, &t);
}
chmod(full_name, file_entry->mode);
lchown(full_name, file_entry->uid, file_entry->gid);
} else {
/* If we arent extracting data we have to skip it,
* if data size is 0 then then just do it anyway
* (saves testing for it) */
seek_sub_file(src_stream, file_entry->size);
}
/* extract_list and extract_verbose_list can be used in conjunction
* with one of the above four extraction functions, so do this seperately */
if (function & extract_verbose_list) {
fprintf(out_stream, "%s %d/%d %8d %s ", mode_string(file_entry->mode),
file_entry->uid, file_entry->gid,
(int) file_entry->size, time_string(file_entry->mtime));
}
if ((function & extract_list) || (function & extract_verbose_list)){
/* fputs doesnt add a trailing \n, so use fprintf */
fprintf(out_stream, "%s\n", file_entry->name);
}
free(full_name);
return(NULL); /* Maybe we should say if failed */
}
#if defined BB_AR || defined BB_CPIO || defined BB_UNTAR
char *unarchive(FILE *src_stream, void *(*get_headers)(FILE *),
const int extract_function, const char *prefix, char **extract_names)
{
file_header_t *file_entry;
int found;
int i;
char *buffer = NULL;
archive_offset = 0;
while ((file_entry = (file_header_t *) get_headers(src_stream)) != NULL) {
found = FALSE;
if (extract_names[0] != NULL) {
for(i = 0; extract_names[i] != 0; i++) {
if (strcmp(extract_names[i], file_entry->name) == 0) {
found = TRUE;
}
}
if (!found) {
/* seek past the data entry */
if (!S_ISLNK(file_entry->mode) && file_entry->link_name && file_entry->size == 0) {
error_msg("You should extract %s as other files are hardlinked to it", file_entry->name);
}
seek_sub_file(src_stream, file_entry->size);
continue;
}
}
buffer = extract_archive(src_stream, stdout, file_entry, extract_function, prefix);
}
return(buffer);
}
#endif
#if defined BB_AR || defined BB_DPKG_DEB || defined BB_DPKG
void *get_header_ar(FILE *src_stream)
{
file_header_t *typed;
union {
char raw[60];
struct {
char name[16];
char date[12];
char uid[6];
char gid[6];
char mode[8];
char size[10];
char magic[2];
} formated;
} ar;
static char *ar_long_names;
if (fread(ar.raw, 1, 60, src_stream) != 60) {
return(NULL);
}
archive_offset += 60;
/* align the headers based on the header magic */
if ((ar.formated.magic[0] != '`') || (ar.formated.magic[1] != '\n')) {
/* some version of ar, have an extra '\n' after each data entry,
* this puts the next header out by 1 */
if (ar.formated.magic[1] != '`') {
error_msg("Invalid magic");
return(NULL);
}
/* read the next char out of what would be the data section,
* if its a '\n' then it is a valid header offset by 1*/
archive_offset++;
if (fgetc(src_stream) != '\n') {
error_msg("Invalid magic");
return(NULL);
}
/* fix up the header, we started reading 1 byte too early */
/* raw_header[60] wont be '\n' as it should, but it doesnt matter */
memmove(ar.raw, &ar.raw[1], 59);
}
typed = (file_header_t *) xcalloc(1, sizeof(file_header_t));
typed->size = (size_t) atoi(ar.formated.size);
/* long filenames have '/' as the first character */
if (ar.formated.name[0] == '/') {
if (ar.formated.name[1] == '/') {
/* If the second char is a '/' then this entries data section
* stores long filename for multiple entries, they are stored
* in static variable long_names for use in future entries */
ar_long_names = (char *) xrealloc(ar_long_names, typed->size);
fread(ar_long_names, 1, typed->size, src_stream);
archive_offset += typed->size;
/* This ar entries data section only contained filenames for other records
* they are stored in the static ar_long_names for future reference */
return(NULL);
} else {
/* The number after the '/' indicates the offset in the ar data section
(saved in variable long_name) that conatains the real filename */
if (!ar_long_names) {
error_msg("Cannot resolve long file name");
return (NULL);
}
typed->name = xstrdup(ar_long_names + atoi(&ar.formated.name[1]));
}
} else {
/* short filenames */
typed->name = xcalloc(1, 16);
strncpy(typed->name, ar.formated.name, 16);
}
typed->name[strcspn(typed->name, " /")]='\0';
/* convert the rest of the now valid char header to its typed struct */
parse_mode(ar.formated.mode, &typed->mode);
typed->mtime = atoi(ar.formated.date);
typed->uid = atoi(ar.formated.uid);
typed->gid = atoi(ar.formated.gid);
return(typed);
}
#endif
#if defined BB_CPIO
void *get_header_cpio(FILE *src_stream)
{
file_header_t *cpio_entry = NULL;
char cpio_header[110];
char dummy[14];
int namesize;
int major, minor, nlink;
/* There can be padding before archive header */
seek_sub_file(src_stream, (4 - (archive_offset % 4)) % 4);
if (fread(cpio_header, 1, 110, src_stream) == 110) {
archive_offset += 110;
if (strncmp(cpio_header, "07070", 5) != 0) {
error_msg("Unsupported format or invalid magic");
return(NULL);
}
switch (cpio_header[5]) {
case '2': /* "crc" header format */
/* Doesnt do the crc check yet */
case '1': /* "newc" header format */
cpio_entry = (file_header_t *) xcalloc(1, sizeof(file_header_t));
sscanf(cpio_header, "%14c%8x%8x%8x%8x%8lx%8lx%16c%8x%8x%8x%8c",
dummy, &cpio_entry->mode, &cpio_entry->uid, &cpio_entry->gid,
&nlink, &cpio_entry->mtime, &cpio_entry->size,
dummy, &major, &minor, &namesize, dummy);
cpio_entry->name = (char *) xcalloc(1, namesize);
fread(cpio_entry->name, 1, namesize, src_stream); /* Read in filename */
archive_offset += namesize;
/* Skip padding before file contents */
seek_sub_file(src_stream, (4 - (archive_offset % 4)) % 4);
if (strcmp(cpio_entry->name, "TRAILER!!!") == 0) {
printf("%d blocks\n", (int) (archive_offset % 512 ? (archive_offset / 512) + 1 : archive_offset / 512)); /* Always round up */
return(NULL);
}
if (S_ISLNK(cpio_entry->mode)) {
cpio_entry->link_name = (char *) xcalloc(1, cpio_entry->size + 1);
fread(cpio_entry->link_name, 1, cpio_entry->size, src_stream);
archive_offset += cpio_entry->size;
}
if (nlink > 1 && !S_ISDIR(cpio_entry->mode) && cpio_entry->size == 0) {
error_msg("%s not extracted: Cannot handle hard links yet", cpio_entry->name);
return(get_header_cpio(src_stream)); /* Recurse to next file */
}
cpio_entry->device = (major << 8) | minor;
break;
default:
error_msg("Unsupported format");
return(NULL);
}
if (ferror(src_stream) || feof(src_stream)) {
perror_msg("Stream error");
return(NULL);
}
}
return(cpio_entry);
}
#endif
#if defined BB_UNTAR || defined BB_DPKG_DEB || defined BB_DPKG
void *get_header_tar(FILE *tar_stream)
{
union {
unsigned char raw[512];
struct {
char name[100]; /* 0-99 */
char mode[8]; /* 100-107 */
char uid[8]; /* 108-115 */
char gid[8]; /* 116-123 */
char size[12]; /* 124-135 */
char mtime[12]; /* 136-147 */
char chksum[8]; /* 148-155 */
char typeflag; /* 156-156 */
char linkname[100]; /* 157-256 */
char magic[6]; /* 257-262 */
char version[2]; /* 263-264 */
char uname[32]; /* 265-296 */
char gname[32]; /* 297-328 */
char devmajor[8]; /* 329-336 */
char devminor[8]; /* 337-344 */
char prefix[155]; /* 345-499 */
char padding[12]; /* 500-512 */
} formated;
} tar;
file_header_t *tar_entry = NULL;
long i;
long sum = 0;
if (archive_offset % 512 != 0) {
seek_sub_file(tar_stream, 512 - (archive_offset % 512));
}
if (fread(tar.raw, 1, 512, tar_stream) != 512) {
error_msg("Couldnt read header");
return(NULL);
}
archive_offset += 512;
/* Check header has valid magic, unfortunately some tar files
* have empty (0'ed) tar entries at the end, which will
* cause this to fail, so fail silently for now
*/
if (strncmp(tar.formated.magic, "ustar", 5) != 0) {
return(NULL);
}
/* Do checksum on headers */
for (i = 0; i < 148 ; i++) {
sum += tar.raw[i];
}
sum += ' ' * 8;
for (i = 156; i < 512 ; i++) {
sum += tar.raw[i];
}
if (sum != strtol(tar.formated.chksum, NULL, 8)) {
error_msg("Invalid tar header checksum");
return(NULL);
}
/* convert to type'ed variables */
tar_entry = xcalloc(1, sizeof(file_header_t));
tar_entry->name = xstrdup(tar.formated.name);
parse_mode(tar.formated.mode, &tar_entry->mode);
tar_entry->uid = strtol(tar.formated.uid, NULL, 8);
tar_entry->gid = strtol(tar.formated.gid, NULL, 8);
tar_entry->size = strtol(tar.formated.size, NULL, 8);
tar_entry->mtime = strtol(tar.formated.mtime, NULL, 8);
tar_entry->link_name = strlen(tar.formated.linkname) ? xstrdup(tar.formated.linkname) : NULL;
tar_entry->device = (strtol(tar.formated.devmajor, NULL, 8) << 8) +
strtol(tar.formated.devminor, NULL, 8);
return(tar_entry);
}
#endif
#if defined BB_DPKG || defined BB_DPKG_DEB
char *deb_extract(const char *package_filename, FILE *out_stream, const int extract_function,
const char *prefix, const char *filename)
{
FILE *deb_stream;
FILE *uncompressed_stream = NULL;
file_header_t *ar_header = NULL;
char *output_buffer = NULL;
char *ared_file = NULL;
char ar_magic[8];
char **file_list;
int gunzip_pid;
file_list = malloc(sizeof(char *));
file_list[0] = xstrdup(filename);
file_list[1] = NULL;
if (extract_function & extract_control_tar_gz) {
ared_file = xstrdup("control.tar.gz");
}
else if (extract_function & extract_data_tar_gz) {
ared_file = xstrdup("data.tar.gz");
}
/* open the debian package to be worked on */
deb_stream = wfopen(package_filename, "r");
/* check ar magic */
fread(ar_magic, 1, 8, deb_stream);
if (strncmp(ar_magic,"!<arch>",7) != 0) {
error_msg_and_die("invalid magic");
}
archive_offset = 8;
while ((ar_header = get_header_ar(deb_stream)) != NULL) {
if (strcmp(ared_file, ar_header->name) == 0) {
/* open a stream of decompressed data */
uncompressed_stream = gz_open(deb_stream, &gunzip_pid);
archive_offset = 0;
output_buffer = unarchive(uncompressed_stream, get_header_tar, extract_function, prefix, file_list);
}
seek_sub_file(deb_stream, ar_header->size);
}
gz_close(gunzip_pid);
fclose(deb_stream);
fclose(uncompressed_stream);
free(ared_file);
return(output_buffer);
}
#endif