bool array_deserialize(const char *src_file, void *dst_data, const size_t elem_size, const size_t elem_count)
{
if (! src_file || ! dst_data || elem_size == 0 || elem_count == 0)
{
return false;
}
FILE* file = fopen(src_file, "r");
if (! file || ! is_valid_filename(src_file))
{
//file didn't open properly
return false;
}
//get number of elements read
int bRead = fread(dst_data, elem_size, elem_count, file);
//check to see they were all read
if (bRead != elem_count)
{
return false; //not all the elements were read!
}
//else, all the bytes were read....
return true;
return true;
}
bool array_serialize(const void *src_data, const char *dst_file, const size_t elem_size, const size_t elem_count)
{
if (! src_data || ! dst_file || elem_size == 0 || elem_count == 0)
{
return false;
}
FILE* file = fopen(dst_file, "w");
if (! file || ! is_valid_filename(dst_file))
{
//file couldn't open properly
return false;
}
//get the number of elements written
int bWritten = fwrite(src_data, elem_size, elem_count, file);
//cleanup
fclose(file);
//check to see they were all written
if (bWritten != elem_count)
{
return false; //not all the bytes were written!
}
//else, all the bytes were written...
return true;
}
/***********************************************************************//**
* @brief Get application parameters
*
* Get all task parameters from parameter file or (if required) by querying
* the user. The parameters are read in the correct order.
***************************************************************************/
void ctexpcube::get_parameters(void)
{
// Setup observations from "inobs" parameter. Do not accept counts cubes.
setup_observations(m_obs, true, true, false);
// Get the incube filename
std::string incube = (*this)["incube"].filename();
// If the "incube" file name is valid then setup the exposure cube from
// the counts cube. Otherwise create a counts cube from the user
// parameters
GCTAEventCube cube = is_valid_filename(incube) ? GCTAEventCube(incube)
: create_cube(m_obs);
// Define exposure cube
m_expcube = GCTACubeExposure(cube);
// Get remaining parameters
m_addbounds = (*this)["addbounds"].boolean();
m_publish = (*this)["publish"].boolean();
m_chatter = static_cast<GChatter>((*this)["chatter"].integer());
// Read output filename (if needed)
if (read_ahead()) {
m_outcube = (*this)["outcube"].filename();
}
// Write parameters into logger
log_parameters(TERSE);
// Return
return;
}
/********************************************//**
*
* This is the main method which will start the compiler.
* 1) Check if the file name contains .ps, if not it will exit.
* 2) Do the first Transition.
* 3) Do the second transition.
* 4) Check for errors, if errors exist it will print them and exit the program
* before writing the files.
* 5) Generate the required files.
*
***********************************************/
int main(int argc, char *argv[]) {
Compiler *compiler = NULL;
int curFileIdx = 1;
if (argc == 1) {
printf("No input files to compile!\n");
exit(0);
} else {
while (--argc) {
if (is_valid_filename(argv[curFileIdx]) == FALSE)
exit(0);
init_compiler(&compiler, BASE_OFFSET, argv[curFileIdx]);
first_transition(compiler);
second_transition(compiler);
if (check_errors(compiler)) {
//printf("errors\n");
print_errors(compiler);
exit(0);
} else
generate_files(compiler);
free(compiler);
curFileIdx++;
}
}
printf("Compilation finished successfully.\n");
return 0;
}
static void handle_event(struct inotify_event *ievent)
{
char *event_filename;
char *dirname = NULL;
char *fullname;
assert(ievent);
if (ievent->len) {
event_filename = ievent->name;
} else {
return;
}
for (size_t i = 0; i < wds_count; i++) {
if (wds[i] == ievent->wd) {
dirname = dirnames[i];
break;
}
}
assert(dirname);
fullname = strjoin(dirname, "/", event_filename, NULL);
switch (ievent->mask & (IN_CLOSE_WRITE | IN_CREATE)) {
case IN_CLOSE_WRITE:
// We don't treat directories modifications
if (ievent->mask & IN_ISDIR) {
break;
}
if (!is_valid_filename(event_filename)) {
break;
}
reload_callback(callback_arg, fullname);
break;
case IN_CREATE:
// recursively watch new dirs
if (!(ievent->mask & IN_ISDIR)) {
break;
}
livecoding_watch_directory(fullname);
break;
default:
break;
}
free(fullname);
}
int ShortcutDialog::check_values()
{
Glib::ustring path = path_entry.get_text() ;
Glib::ustring display = display_entry.get_text() ;
//TODO check display for correct
if (path=="")
return -2 ;
else if (display=="")
return -1 ;
else if ( !Glib::file_test(path, Glib::FILE_TEST_EXISTS) )
return -4 ;
else if ( manager->exist_tree(path, number_tree) )
return -3 ;
//don't check name for default system name (ftp cache file, work directory)
else if (is_valid_filename(display)<0 && !lock_name)
return -5 ;
else if (!FileHelper::is_readable(path)||!FileHelper::is_executable(path))
return -6 ;
else
return 1 ;
}
int main(int argc, const char **argv) {
srand (time(NULL));
try {
string chrom_file;
string outfile;
/****************** COMMAND LINE OPTIONS ********************/
OptionParser opt_parse(strip_path(argv[0]),
"build index for reference genome", "");
opt_parse.add_opt(
"chrom",
'c',
"chromosomes in FASTA file or dir \
(the suffix of the chromosome file should be '.fa')",
true, chrom_file);
opt_parse.add_opt(
"output", 'o',
"output file name (the suffix of the file should be '.dbindex')", true,
outfile);
vector<string> leftover_args;
opt_parse.parse(argc, argv, leftover_args);
if (argc == 1 || opt_parse.help_requested()) {
fprintf(stderr, "%s\n", opt_parse.help_message().c_str());
return EXIT_SUCCESS;
}
if (opt_parse.about_requested()) {
fprintf(stderr, "%s\n", opt_parse.about_message().c_str());
return EXIT_SUCCESS;
}
if (opt_parse.option_missing()) {
fprintf(stderr, "%s\n", opt_parse.option_missing_message().c_str());
return EXIT_SUCCESS;
}
if (!is_valid_filename(outfile, "dbindex")) {
fprintf(stderr, "The suffix of the output file should be '.dbindex'\n");
return EXIT_FAILURE;
}
if (outfile.size() > 1000) {
fprintf(stderr, "The output file name is too long, "
"please select a shorter name\n");
return EXIT_FAILURE;;
}
/****************** END COMMAND LINE OPTIONS *****************/
//////////////////////////////////////////////////////////////
// READ GENOME
//
vector<string> chrom_files;
IdentifyChromosomes(chrom_file, chrom_files);
//////////////////////////////////////////////////////////////
// BUILD INDEX
//
uint32_t size_of_index = 0;
////////// BUILD INDEX FOR FORWARD STRAND (C->T)
BuildIndex(chrom_files, 0, outfile + "_CT00", size_of_index);
////////// BUILD INDEX FOR REVERSE STRAND (C->T)
BuildIndex(chrom_files, 1, outfile + "_CT01", size_of_index);
////////// BUILD INDEX FOR FORWARD STRAND (G->A)
BuildIndex(chrom_files, 2, outfile + "_GA10", size_of_index);
////////// BUILD INDEX FOR REVERSE STRAND (G->A)
BuildIndex(chrom_files, 3, outfile + "_GA11", size_of_index);
Genome genome;
ReadGenome(chrom_files, genome);
WriteIndexHeadInfo(outfile, genome, size_of_index);
} catch (const SMITHLABException &e) {
fprintf(stderr, "%s\n", e.what().c_str());
return EXIT_FAILURE;
} catch (std::bad_alloc &ba) {
fprintf(stderr, "ERROR: could not allocate memory\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(int argc, const char **argv) {
srand (time(NULL));
try {
string command = argv[0];
bool help_info = false;
for (int i = 1; i < argc; i++) {
command += " ";
command += argv[i];
if (strcmp(argv[i], "-help") == 0 || strcmp(argv[i], "-about") == 0
|| strcmp(argv[i], "-?") == 0) {
help_info = true;
}
}
if (argc > 1 && help_info == false) {
/* show the command line one the screen */
fprintf(stderr, "[WELCOME TO WALT v%s]\n", walt_version);
fprintf(stderr, "[%s", argv[0]);
for (int i = 1; i < argc; i++) {
fprintf(stderr, " %s", argv[i]);
}
fprintf(stderr, "]\n");
}
/* singled-end reads file, comma-separated list of files */
string reads_file_s;
vector<string> v_reads_file_s;
/* paired-end reads files, comma-separated list of files*/
string reads_file_p1;
string reads_file_p2;
vector<string> v_reads_file_p1;
vector<string> v_reads_file_p2;
/* index file*/
string index_file;
/* output file */
string output_file;
vector<string> v_output_file;
/* WALT supports Tab-delimited SAM and MR output formats.
* By default, WALT produces SAM format output files. To
* get MR format, the suffix of the output file should be
* ".mr". */
bool SAM = true;
/* trimming adaptor sequence */
string adaptor;
/* paired-end or single-end mapping */
bool is_paired_end_reads = false;
/* output ambiguous or unmapped reads or not, both are false by default */
bool ambiguous = false;
bool unmapped = false;
/* AG_WILDCARD is false by default, which means that all Cs
* in the reads and genome are converted to Ts.
* If AG_WILDCARD is true, all Gs in the reads and genome
* are converted to As. If option is only for single-end mapping */
bool AG_WILDCARD = false;
/* maximum allowed mismatches */
uint32_t max_mismatches = 6;
/* number of reads to map at one loop */
uint32_t n_reads_to_process = 1000000;
/* paired-end reads: keep top k genome positions for each in the pair */
uint32_t top_k = 50;
/* max fragment length for paired end reads */
int frag_range = 1000;
/* number of threads for mapping */
int num_of_threads = 1;
/****************** COMMAND LINE OPTIONS ********************/
OptionParser opt_parse(strip_path(argv[0]), "map Illumina BS-seq reads",
"");
opt_parse.add_opt(
"index",
'i',
"index file created by makedb command \
(the suffix of the index file should be '.dbindex')",
true, index_file);
opt_parse.add_opt(
"reads",
'r',
"comma-separated list of read files for singled-end mapping \
(the suffix of read files should be '.fastq' or '.fq')",
false, reads_file_s);
opt_parse.add_opt(
"reads1",
'1',
"comma-separated list of read files for mate 1 \
(the suffix of read files should be '.fastq' or '.fq')",
false, reads_file_p1);
opt_parse.add_opt(
"reads2",
'2',
"comma-separated list of read files for mate 2 \
(the suffix of read files should be '.fastq' or '.fq')",
false, reads_file_p2);
opt_parse.add_opt("output", 'o', "output file name", true, output_file);
opt_parse.add_opt("mismatch", 'm', "maximum allowed mismatches", false,
max_mismatches);
opt_parse.add_opt("number", 'N', "number of reads to map at one loop",
false, n_reads_to_process);
opt_parse.add_opt(
"ambiguous",
'a',
"randomly output one mapped position for ambiguous \
reads in a separated file",
false, ambiguous);
opt_parse.add_opt("unmapped", 'u',
"output unmapped reads in a separated file", false,
unmapped);
opt_parse.add_opt("clip", 'C', "clip the specified adaptor", false,
adaptor);
opt_parse.add_opt("ag-wild", 'A',
"map using A/G bisulfite wildcards (single-end)", false,
AG_WILDCARD);
opt_parse.add_opt("topk", 'k',
"maximum allowed mappings for a read (paired-end)", false,
top_k);
opt_parse.add_opt("fraglen", 'L', "max fragment length (paired-end)", false,
frag_range);
opt_parse.add_opt("thread", 't', "number of threads for mapping", false,
num_of_threads);
vector<string> leftover_args;
opt_parse.parse(argc, argv, leftover_args);
if (argc == 1 || opt_parse.help_requested()) {
fprintf(stderr, "%s\n", opt_parse.help_message().c_str());
return EXIT_SUCCESS;
}
if (opt_parse.about_requested()) {
fprintf(stderr, "%s\n", opt_parse.about_message().c_str());
return EXIT_SUCCESS;
}
if (opt_parse.option_missing()) {
fprintf(stderr, "%s\n", opt_parse.option_missing_message().c_str());
return EXIT_SUCCESS;
}
if (!is_valid_filename(index_file, "dbindex")) {
fprintf(stderr, "The suffix of the index file should be '.dbindex'\n");
return EXIT_FAILURE;
}
if (!reads_file_s.empty() && reads_file_p1.empty()
&& reads_file_p2.empty()) {
is_paired_end_reads = false;
} else if (reads_file_s.empty() && !reads_file_p1.empty()
&& !reads_file_p2.empty()) {
is_paired_end_reads = true;
} else {
fprintf(stderr, "Please use -r option to set singled-end reads, \n"
"-1 and -2 options to set paired-end reads\n");
return EXIT_FAILURE;
}
/****************** END COMMAND LINE OPTIONS *****************/
bool get_empty_fields = false;
if (!is_paired_end_reads) {
v_reads_file_s = smithlab::split(reads_file_s, ",", get_empty_fields);
for (uint32_t i = 0; i < v_reads_file_s.size(); ++i) {
if (!is_valid_filename(v_reads_file_s[i], "fastq")
&& !is_valid_filename(v_reads_file_s[i], "fq")) {
fprintf(stderr,
"The suffix of the reads file should be '.fastq', '.fq'\n");
return EXIT_FAILURE;
}
}
} else {
v_reads_file_p1 = smithlab::split(reads_file_p1, ",", get_empty_fields);
v_reads_file_p2 = smithlab::split(reads_file_p2, ",", get_empty_fields);
if (v_reads_file_p1.size() != v_reads_file_p2.size()) {
fprintf(
stderr,
"For paired-end mapping, mate 1 and mate 2 should \n\
have the same number of files, and the paired files \n\
should be in the same order.");
return EXIT_FAILURE;
}
for (uint32_t i = 0; i < v_reads_file_p1.size(); ++i) {
if (!is_valid_filename(v_reads_file_p1[i], "fastq")
&& !is_valid_filename(v_reads_file_p1[i], "fq")) {
fprintf(stderr,
"The suffix of the reads file should be '.fastq', '.fq'\n");
return EXIT_FAILURE;
}
}
}
if (!is_paired_end_reads) {
if (v_reads_file_s.size() == 1) {
v_output_file.push_back(output_file);
} else {
char output_filename[1000];
for (uint32_t i = 0; i < v_reads_file_s.size(); ++i) {
sprintf(output_filename, "%s_s%u", output_file.c_str(), i);
v_output_file.push_back(output_filename);
}
}
} else {
if (v_reads_file_p1.size() == 1) {
v_output_file.push_back(output_file);
} else {
char output_filename[1000];
for (uint32_t i = 0; i < v_reads_file_p1.size(); ++i) {
sprintf(output_filename, "%s_p%u", output_file.c_str(), i);
v_output_file.push_back(output_filename);
}
}
}
for (uint32_t i = 0; i < v_reads_file_p2.size(); ++i) {
if (!is_valid_filename(v_reads_file_p2[i], "fastq")
&& !is_valid_filename(v_reads_file_p2[i], "fq")) {
fprintf(stderr,
"The suffix of the reads file should be '.fastq', '.fq'\n");
return EXIT_FAILURE;
}
}
size_t suffix_pos = output_file.find_last_of(".");
if (suffix_pos == string::npos) {
SAM = true;
} else if (".mr" == output_file.substr(suffix_pos)) {
SAM = false;
}
/****************** END COMMAND LINE OPTIONS *****************/
//////////////////////////////////////////////////////////////
// CHECK OPTIONS
fprintf(stderr, "[MAXIMUM NUMBER OF MISMATCHES IS %u]\n", max_mismatches);
fprintf(stderr, "[NUMBER OF THREADS FOR MAPPING IS %d]\n", num_of_threads);
if (n_reads_to_process > 5000000) {
n_reads_to_process = 5000000;
}
if (is_paired_end_reads && top_k < 2) {
fprintf(stderr, "-k option should be at least 2 for paired-end reads\n");
return EXIT_FAILURE;
}
if (is_paired_end_reads && top_k > 300) {
fprintf(stderr,
"-k option should be less than 300 for paired-end reads\n");
return EXIT_FAILURE;
}
ShowGenomeInfo(index_file);
//////////////////////////////////////////////////////////////
// Mapping
if (!is_paired_end_reads) {
for (uint32_t i = 0; i < v_reads_file_s.size(); ++i) {
ProcessSingledEndReads(command, index_file, v_reads_file_s[i],
v_output_file[i], n_reads_to_process,
max_mismatches, adaptor, AG_WILDCARD, ambiguous,
unmapped, SAM, num_of_threads);
}
} else {
for (uint32_t i = 0; i < v_reads_file_p1.size(); ++i) {
ProcessPairedEndReads(command, index_file, v_reads_file_p1[i],
v_reads_file_p2[i], v_output_file[i],
n_reads_to_process, max_mismatches, adaptor,
top_k, frag_range, ambiguous, unmapped, SAM,
num_of_threads);
}
}
} catch (const SMITHLABException &e) {
void do_bset( CHAR_DATA * ch, char *argument )
{
BOARD_DATA *board = NULL;
bool found = FALSE;
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char buf[MAX_STRING_LENGTH];
int value = 0;
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if( arg1[0] == '\0' || arg2[0] == '\0' )
{
send_to_char( "Usage: bset <board filename> <field> value\r\n", ch );
send_to_char( "\r\nField being one of:\r\n", ch );
send_to_char( " vnum read post remove maxpost filename type\r\n", ch );
send_to_char
( " read_group post_group extra_readers extra_removers\r\n", ch );
return;
}
value = atoi( argument );
for( board = first_board; board; board = board->next )
if( !str_cmp( arg1, board->note_file ) )
{
found = TRUE;
break;
}
if( !found )
{
send_to_char( "Board not found.\r\n", ch );
return;
}
if( !str_cmp( arg2, "vnum" ) )
{
if( !get_obj_index( value ) )
{
send_to_char( "No such object.\r\n", ch );
return;
}
board->board_obj = value;
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "read" ) )
{
if( value < 0 || value > MAX_LEVEL )
{
send_to_char( "Value out of range.\r\n", ch );
return;
}
board->min_read_level = value;
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "read_group" ) )
{
if( !argument || argument[0] == '\0' )
{
send_to_char( "No group specified.\r\n", ch );
return;
}
DISPOSE( board->read_group );
if( !str_cmp( argument, "none" ) )
board->read_group = str_dup( "" );
else
board->read_group = str_dup( argument );
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "post_group" ) )
{
if( !argument || argument[0] == '\0' )
{
send_to_char( "No group specified.\r\n", ch );
return;
}
DISPOSE( board->post_group );
if( !str_cmp( argument, "none" ) )
board->post_group = str_dup( "" );
else
board->post_group = str_dup( argument );
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "extra_removers" ) )
{
if( !argument || argument[0] == '\0' )
{
send_to_char( "No names specified.\r\n", ch );
return;
}
if( !str_cmp( argument, "none" ) )
buf[0] = '\0';
else
sprintf( buf, "%s %s", board->extra_removers, argument );
DISPOSE( board->extra_removers );
board->extra_removers = str_dup( buf );
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "extra_readers" ) )
{
if( !argument || argument[0] == '\0' )
{
send_to_char( "No names specified.\r\n", ch );
return;
}
if( !str_cmp( argument, "none" ) )
buf[0] = '\0';
else
sprintf( buf, "%s %s", board->extra_readers, argument );
DISPOSE( board->extra_readers );
board->extra_readers = str_dup( buf );
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "filename" ) )
{
char filename[256];
if( !is_valid_filename( ch, BOARD_DIR, argument ) )
return;
sprintf( filename, "%s%s", BOARD_DIR, board->note_file );
if( !remove( filename ) )
send_to_char( "Old board file deleted.\r\n", ch );
DISPOSE( board->note_file );
board->note_file = str_dup( argument );
write_boards_txt();
send_to_char( "Done. (board's filename set)\r\n", ch );
return;
}
if( !str_cmp( arg2, "post" ) )
{
if( value < 0 || value > MAX_LEVEL )
{
send_to_char( "Value out of range.\r\n", ch );
return;
}
board->min_post_level = value;
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "remove" ) )
{
if( value < 0 || value > MAX_LEVEL )
{
send_to_char( "Value out of range.\r\n", ch );
return;
}
board->min_remove_level = value;
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "maxpost" ) )
{
if( value < 1 || value > 1000 )
{
send_to_char( "Value out of range.\r\n", ch );
return;
}
board->max_posts = value;
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
if( !str_cmp( arg2, "type" ) )
{
if( value < 0 || value > 1 )
{
send_to_char( "Value out of range.\r\n", ch );
return;
}
board->type = value;
write_boards_txt();
send_to_char( "Done.\r\n", ch );
return;
}
do_bset( ch, STRLIT_EMPTY );
}
static int zwr(struct zws *zws, size_t offset)
{
int err, fd;
size_t len;
DIR *dir;
struct dirent *ent;
zip_int64_t z64;
struct zip_source *zsrc;
FILE *fp;
fd = openat(workdirfd, offset ? zws->name : ".", O_DIRECTORY|O_RDONLY);
if (fd < 0) {
ERROR("opendir %.*s failed in zwr", (int)offset, zws->name);
return -1;
}
dir = fdopendir(fd);
if (!dir) {
close(fd);
ERROR("opendir %.*s failed in zwr", (int)offset, zws->name);
return -1;
}
if (offset != 0)
zws->name[offset++] = '/';
ent = readdir(dir);
while (ent != NULL) {
len = strlen(ent->d_name);
if (ent->d_name[0] == '.' && (len == 1 ||
(ent->d_name[1] == '.' && len == 2)))
;
else if (offset + len >= sizeof(zws->name)) {
ERROR("name too long in zwr");
errno = ENAMETOOLONG;
goto error;
} else {
memcpy(zws->name + offset, ent->d_name, 1+len);
if (!is_valid_filename(ent->d_name)) {
ERROR("invalid name %s", zws->name);
goto error;
}
switch (ent->d_type) {
case DT_DIR:
z64 = zip_dir_add(zws->zip, zws->name, ZIP_FL_ENC_UTF_8);
if (z64 < 0) {
ERROR("zip_dir_add of %s failed", zws->name);
goto error;
}
err = zwr(zws, offset + len);
if (err)
goto error;
break;
case DT_REG:
fd = openat(workdirfd, zws->name, O_RDONLY);
if (fd < 0) {
ERROR("openat of %s failed", zws->name);
goto error;
}
fp = fdopen(fd, "r");
if (fp == NULL) {
ERROR("fdopen of %s failed", zws->name);
close(fd);
goto error;
}
zsrc = zip_source_filep(zws->zip, fp, 0, 0);
if (zsrc == NULL) {
ERROR("zip_source_file of %s failed", zws->name);
fclose(fp);
goto error;
}
z64 = zip_file_add(zws->zip, zws->name, zsrc, ZIP_FL_ENC_UTF_8);
if (z64 < 0) {
ERROR("zip_file_add of %s failed", zws->name);
zip_source_free(zsrc);
goto error;
}
break;
default:
break;
}
}
ent = readdir(dir);
}
closedir(dir);
return 0;
error:
closedir(dir);
return -1;
}
/* read (extract) 'zipfile' in current directory */
int zread(const char *zipfile, unsigned long long maxsize)
{
struct filedesc *fdesc;
int err, fd;
size_t len;
struct zip *zip;
zip_int64_t z64;
zip_uint64_t uz64;
unsigned int count, index;
struct zip_file *zfile;
struct zip_stat zstat;
char buffer[32768];
ssize_t sizr, sizw;
size_t esize;
/* open the zip file */
zip = zip_open(zipfile, ZIP_CHECKCONS, &err);
if (!zip) {
ERROR("Can't connect to file %s", zipfile);
return -1;
}
z64 = zip_get_num_entries(zip, 0);
if (z64 < 0 || z64 > UINT_MAX) {
ERROR("too many entries in %s", zipfile);
goto error;
}
count = (unsigned int)z64;
/* records the files */
file_reset();
esize = 0;
for (index = 0 ; index < count ; index++) {
err = zip_stat_index(zip, index, ZIP_FL_ENC_GUESS, &zstat);
/* check the file name */
if (!is_valid_filename(zstat.name)) {
ERROR("invalid entry %s found in %s", zstat.name, zipfile);
goto error;
}
if (zstat.name[0] == '/') {
ERROR("absolute entry %s found in %s", zstat.name, zipfile);
goto error;
}
len = strlen(zstat.name);
if (len == 0) {
ERROR("empty entry found in %s", zipfile);
goto error;
}
if (zstat.name[len - 1] == '/')
/* record */
fdesc = file_add_directory(zstat.name);
else {
/* get the size */
esize += zstat.size;
/* record */
fdesc = file_add_file(zstat.name);
}
if (!fdesc)
goto error;
fdesc->zindex = index;
}
/* check the size */
if (maxsize && esize > maxsize) {
ERROR("extracted size %zu greater than allowed size %llu", esize, maxsize);
goto error;
}
/* unpack the recorded files */
assert(count == file_count());
for (index = 0 ; index < count ; index++) {
fdesc = file_of_index(index);
assert(fdesc != NULL);
err = zip_stat_index(zip, fdesc->zindex, ZIP_FL_ENC_GUESS, &zstat);
assert(zstat.name[0] != '/');
len = strlen(zstat.name);
assert(len > 0);
if (zstat.name[len - 1] == '/') {
/* directory name */
err = create_directory((char*)zstat.name, MODE_OF_DIRECTORY_CREATION);
if (err && errno != EEXIST)
goto error;
} else {
/* file name */
zfile = zip_fopen_index(zip, fdesc->zindex, 0);
if (!zfile) {
ERROR("Can't open %s in %s", zstat.name, zipfile);
goto error;
}
fd = create_file((char*)zstat.name, MODE_OF_FILE_CREATION, MODE_OF_DIRECTORY_CREATION);
if (fd < 0)
goto errorz;
/* extract */
uz64 = zstat.size;
while (uz64) {
sizr = zip_fread(zfile, buffer, sizeof buffer);
if (sizr < 0) {
ERROR("error while reading %s in %s", zstat.name, zipfile);
goto errorzf;
}
sizw = write(fd, buffer, (size_t)sizr);
if (sizw < 0) {
ERROR("error while writing %s", zstat.name);
goto errorzf;
}
uz64 -= (size_t)sizw;
}
close(fd);
zip_fclose(zfile);
}
}
zip_close(zip);
return 0;
errorzf:
close(fd);
errorz:
zip_fclose(zfile);
error:
zip_close(zip);
return -1;
}
