int
vfs_zip_scandir (const char *dir, struct dirent ***namelist, int (*selector) (const struct dirent *), int (*cmp) (const struct dirent **, const struct dirent **)) {
trace ("vfs_zip_scandir: %s\n", dir);
int error;
struct zip *z = zip_open (dir, 0, &error);
if (!z) {
trace ("zip_open failed (code: %d)\n", error);
return -1;
}
int num_files = 0;
const int n = zip_get_num_files(z);
*namelist = malloc(sizeof(void *) * n);
for (int i = 0; i < n; i++) {
const char *nm = zip_get_name(z, i, 0);
struct dirent entry;
strncpy(entry.d_name, nm, sizeof(entry.d_name)-1);
entry.d_name[sizeof(entry.d_name)-1] = '\0';
if (!selector || selector && selector(&entry)) {
(*namelist)[num_files] = calloc(1, sizeof(struct dirent));
strcpy((*namelist)[num_files]->d_name, entry.d_name);
num_files++;
trace("vfs_zip: %s\n", nm);
}
}
zip_close (z);
trace ("vfs_zip: scandir done\n");
return num_files;
}
int main(int argc, char *argv[]){
int errorp = 0;
struct zip* zipObj = NULL;
int num_entries = 0;
int i;
if( argc < 2){
usage();
return 1;
}
zipObj = zip_open(argv[1],0,&errorp);
if( NULL == zipObj ){
printf("open zip file failed , error code : %d\n",errorp);
return 2;
}
num_entries = zip_get_num_files(zipObj) ;
for( i = 0 ; i < num_entries ; ++i ){
printf("%s\n",zip_get_name(zipObj,i,0) );
}
zip_close(zipObj);
zipObj = NULL ;
return 0;
};
archive_t arch_zip_read(const char* name,int buf){
archive_t arch=(archive_t)HREmalloc(NULL,sizeof(struct archive_s));
arch_init(arch);
int err;
arch->archive=zip_open(name,ZIP_CHECKCONS,&err);
if (arch->archive==NULL){
char errstr[1024];
zip_error_to_str(errstr, sizeof(errstr), err, errno);
Abort("cannot open zip archive `%s': %s\n",name , errstr);
}
arch->stream_index=SIcreate();
#ifdef LIBZIP_VERSION
int count=zip_get_num_entries(arch->archive,0);
#else
int count=zip_get_num_files(arch->archive);
#endif
for(int i=0;i<count;i++){
struct zip_stat sb;
int res=zip_stat_index(arch->archive,i,0,&sb);
if (res<0) {
Abort("cannot stat zip archive: %s\n",zip_strerror(arch->archive));
}
SIputAt(arch->stream_index,sb.name,i);
Print(infoShort,"stream %d is %s",i,sb.name);
}
arch->procs.contains=zip_contains;
arch->procs.read=hre_zip_read;
arch->procs.read_raw=hre_zip_read_raw;
arch->procs.enumerator=zip_enum;
arch->procs.close=hre_zip_close;
arch->buf=buf;
return arch;
}
bool zipobject::extractTo(const QString& dirPath){
int num_entries = zip_get_num_files(m_zip) ;
for( int i = 0 ; i < num_entries ; ++i ){
qDebug()<<zip_get_name(m_zip,i,0);
zip_file* pFile = zip_fopen_index(m_zip,i,0);
struct zip_stat stat ;
zip_stat_index(m_zip,i,0,&stat);
const int length = stat.size ;
char buffer[length +1 ] ;
int rRead = zip_fread(pFile,buffer,sizeof(buffer));
if( -1 == rRead ){
qDebug()<<"read failed : "<<zip_strerror(m_zip);
return false;
}
QFileInfo fileInfo(dirPath + '/' + stat.name);
QDir dir = fileInfo.absoluteDir() ;
if(!dir.mkpath(".")){
return false;
}
QFile file(dirPath + '/' + stat.name);
file.open(QIODevice::WriteOnly);
file.write(QByteArray(buffer,length));
file.close();
}
return true;
}
/*************************************************
Function: readZipFileName
Descroption:
Input:
1.zip* z
2.filetype
Output:
Return:
Other:
*************************************************/
int readZipFileName(struct zip* z, char* filetype)
{
int i;
struct zip_stat fstat;
if(z != NULL)
{
zip_stat_init(&fstat);
int c = zip_get_num_files(z);
if(c > 0)
{
for (i = 0 ; i < c; i++)
{
const char* name = zip_get_name(z, i, 0);
if(name != NULL)
{
zip_stat(z, name,0,&fstat);
//LOGI("File %i:%s Size: %lld Size2: %lld\n", i,fstat.name,fstat.size ,fstat.comp_size);
}
}
}
}
else
{
return -1;
}
return 0;
}
RList * r_io_zip_get_files(char *archivename, ut32 flags, int mode, int rw) {
ut64 num_entries = 0, i = 0;
struct zip * zipArch = r_io_zip_open_archive(archivename, flags, mode, rw);
struct zip_stat sb;
RList *files = NULL;
//eprintf("Slurping file");
if (zipArch) {
files = r_list_new();
num_entries = zip_get_num_files(zipArch);
for (i=0; i < num_entries; i++) {
char *name = NULL;
zip_stat_init(&sb );
zip_stat_index(zipArch, i, 0, &sb );
//eprintf("Comparing %s == %s = %d\n", sb.name, filename, strcmp(sb.name, filename));
name = strdup(sb.name);
if (name) {
r_list_append(files, name);
}
}
}
if (zipArch)
zip_close(zipArch);
return files;
}
/* The file can be a file in the archive or ::[num]. */
RIOZipFileObj* r_io_zip_alloc_zipfileobj(const char *archivename, const char *filename, ut32 perm, int mode, int rw) {
RIOZipFileObj *zfo = NULL;
ut64 i, num_entries;
struct zip_stat sb;
struct zip *zipArch = r_io_zip_open_archive (archivename, perm, mode, rw);
if (!zipArch) {
return NULL;
}
num_entries = zip_get_num_files (zipArch);
for (i = 0; i < num_entries; i++) {
zip_stat_init (&sb);
zip_stat_index (zipArch, i, 0, &sb);
if (sb.name != NULL) {
if (strcmp (sb.name, filename) == 0) {
zfo = r_io_zip_create_new_file (
archivename, filename, &sb,
perm, mode, rw);
r_io_zip_slurp_file (zfo);
break;
}
}
}
if (!zfo) {
zfo = r_io_zip_create_new_file (archivename,
filename, NULL, perm, mode, rw);
}
zip_close (zipArch);
return zfo;
}
bool ZipAssetReader::GetFileListing(const char *path, std::vector<FileInfo> *listing, const char *filter = 0)
{
ILOG("Zip path: %s", path);
// We just loop through the whole ZIP file and deduce what files are in this directory, and what subdirectories there are.
std::set<std::string> files;
std::set<std::string> directories;
int numFiles = zip_get_num_files(zip_file_);
size_t pathlen = strlen(path);
if (path[pathlen-1] == '/')
pathlen--;
for (int i = 0; i < numFiles; i++) {
const char* name = zip_get_name(zip_file_, i, 0);
if (!name)
continue;
ILOG("Comparing %s %s %i", name, path, pathlen);
if (!memcmp(name, path, pathlen)) {
// The prefix is right. Let's see if this is a file or path.
char *slashPos = strchr(name + pathlen + 1, '/');
if (slashPos != 0) {
// A directory.
std::string dirName = std::string(name + pathlen + 1, slashPos - (name + pathlen + 1));
directories.insert(dirName);
} else {
files.insert(std::string(name + pathlen + 1));
}
}
}
for (auto diter = directories.begin(); diter != directories.end(); ++diter) {
FileInfo info;
info.name = *diter;
info.fullName = std::string(path);
if (info.fullName[info.fullName.size()-1] == '/')
info.fullName = info.fullName.substr(0, info.fullName.size() - 1);
info.fullName += "/" + *diter;
info.exists = true;
info.isWritable = false;
info.isDirectory = true;
listing->push_back(info);
}
for (auto fiter = files.begin(); fiter != files.end(); ++fiter) {
FileInfo info;
info.name = *fiter;
info.fullName = std::string(path);
if (info.fullName[info.fullName.size()-1] == '/')
info.fullName = info.fullName.substr(0, info.fullName.size() - 1);
info.fullName += "/" + *fiter;
info.exists = true;
info.isWritable = false;
info.isDirectory = false;
listing->push_back(info);
}
std::sort(listing->begin(), listing->end());
return true;
}
static int S_archive_get_num_files(lua_State* L) {
struct zip** ar = check_archive(L, 1);
if ( ! *ar ) return 0;
lua_pushinteger(L, zip_get_num_files(*ar));
return 1;
}
static VALUE zipruby_archive_num_files(VALUE self) {
struct zipruby_archive *p_archive;
int num_files;
Data_Get_Struct(self, struct zipruby_archive, p_archive);
Check_Archive(p_archive);
num_files = zip_get_num_files(p_archive->archive);
return INT2NUM(num_files);
}
void show(zip_t *archive, const char *text)
{
fprintf(stderr, "--- %s ---\n", text);
int files_total = zip_get_num_files(archive);
int i;
for (i = 0; i<files_total; i++) {
const char *filename = zip_get_name(archive, i, 0);
fprintf(stderr, "file index %d: %s\n", i, filename);
}
}
static int zip_get_app_directory(struct zip* zf, char** path)
{
int i = 0;
int c = zip_get_num_files(zf);
int len = 0;
const char* name = NULL;
/* look through all filenames in the archive */
do {
/* get filename at current index */
name = zip_get_name(zf, i++, 0);
if (name != NULL) {
/* check if we have a "Payload/.../" name */
len = strlen(name);
if (!strncmp(name, "Payload/", 8) && (len > 8)) {
/* locate the second directory delimiter */
const char* p = name + 8;
do {
if (*p == '/') {
break;
}
} while(p++ != NULL);
/* try next entry if not found */
if (p == NULL)
continue;
len = p - name + 1;
if (*path != NULL) {
free(*path);
*path = NULL;
}
/* allocate and copy filename */
*path = (char*)malloc(len + 1);
strncpy(*path, name, len);
/* add terminating null character */
char* t = *path + len;
*t = '\0';
break;
}
}
} while(i < c);
/* check if the path actually exists */
int zindex = zip_name_locate(zf, *path, 0);
if (zindex < 0) {
return -1;
}
return 0;
}
int
main(int argc, char *argv[])
{
const char *archive;
struct zip *za;
char buf[100];
int err;
int i;
prg = argv[0];
if (argc != 2) {
fprintf(stderr, "usage: %s archive\n", prg);
return 1;
}
archive = argv[1];
if ((za=zip_open(archive, 0, &err)) == NULL) {
zip_error_to_str(buf, sizeof(buf), err, errno);
fprintf(stderr,"%s: can't open zip archive `%s': %s\n", prg,
archive, buf);
return 1;
}
if (zip_set_archive_comment(za, new_archive_comment,
strlen(new_archive_comment)) < 0) {
zip_error_to_str(buf, sizeof(buf), err, errno);
fprintf(stderr, "%s: zip_set_archive_comment failed: %s\n",
prg, buf);
}
for (i=0; i<zip_get_num_files(za); i++) {
snprintf(buf, sizeof(buf), "File comment no %d", i);
if (zip_set_file_comment(za, i, buf, strlen(buf)) < 0) {
zip_error_to_str(buf, sizeof(buf), err, errno);
fprintf(stderr, "%s: zip_set_file_comment on file %d failed: %s\n",
prg, i, buf);
}
}
if (zip_unchange_all(za) == -1) {
fprintf(stderr,"%s: can't revert changes to archive `%s'\n", prg, archive);
return 1;
}
if (zip_close(za) == -1) {
fprintf(stderr,"%s: can't close zip archive `%s'\n", prg, archive);
return 1;
}
return 0;
}
void ZipFile::GetNames()
{
int num = zip_get_num_files(this->archive);
this->names.clear();
this->names.reserve(num);
int i = 0;
for (i=0; i<num; i++) {
struct zip_stat st;
zip_stat_index(this->archive, i, 0, &st);
this->names.push_back(st.name);
}
}
static arch_enum_t zip_enum(archive_t archive,char *regex){
if (regex!=NULL) Abort("regex not supported");
arch_enum_t e=(arch_enum_t)HREmalloc(NULL,sizeof(struct arch_enum));
e->procs.enumerate=zip_enumerate;
e->procs.free=zip_enum_free;
e->archive=archive;
e->next=0;
#ifdef LIBZIP_VERSION
e->count=zip_get_num_entries(archive->archive,0);
#else
e->count=zip_get_num_files(archive->archive);
#endif
return e;
}
ResourceManager::ResourceManager(const char *apkFilename): archive(0) {
archive = zip_open(apkFilename, 0, NULL);
if(archive) {
//Just for debug, print APK contents
int numFiles = zip_get_num_files(archive);
for (int i=0; i<numFiles; i++) {
const char* name = zip_get_name(archive, i, 0);
if (name == NULL) {
// LOGE("Error reading zip file name at index %i : %s", zip_strerror(APKArchive));
return;
}
// LOGI("File %i : %s\n", i, name);
}
}
}
int
main(int argc, char *argv[])
{
const char *archive;
struct zip *za;
char buf[100];
int err;
const char *com;
int i, len;
prg = argv[0];
if (argc != 2) {
fprintf(stderr, "usage: %s archive\n", prg);
return 1;
}
archive = argv[1];
if ((za=zip_open(archive, 0, &err)) == NULL) {
zip_error_to_str(buf, sizeof(buf), err, errno);
fprintf(stderr,"%s: can't open zip archive `%s': %s\n", prg,
archive, buf);
return 1;
}
if ((com=zip_get_archive_comment(za, &len, 0)) == NULL)
printf("No archive comment\n");
else
printf("Archive comment: %.*s\n", len, com);
for (i=0; i<zip_get_num_files(za); i++) {
if ((com=zip_get_file_comment(za, i, &len, 0)) == NULL)
printf("No comment for `%s'\n", zip_get_name(za, i, 0));
else
printf("File comment for `%s': %.*s\n", zip_get_name(za, i, 0), len, com);
}
if (zip_close(za) == -1) {
fprintf(stderr,"%s: can't close zip archive `%s'\n", prg, archive);
return 1;
}
return 0;
}
void setAPK (const char* apkPath) {
LOGI("Loading APK %s", apkPath);
APKArchive = zip_open(apkPath, 0, NULL);
if (APKArchive == NULL) {
LOGE("Error loading APK");
return;
}
//Just for debug, print APK contents
int numFiles = zip_get_num_files(APKArchive);
for (int i=0; i<numFiles; i++) {
const char* name = zip_get_name(APKArchive, i, 0);
if (name == NULL) {
LOGE("Error reading zip file name at index %i : %s", i, zip_strerror(APKArchive));
return;
}
LOGI("File %i : %s\n", i, name);
}
}
ZipFileOutput::ZipFileOutput(const std::string& archive)
: m_archiveHandle(0),
m_initialized(false),
m_archive(archive),
m_currentFile(0)
{
int error = 0;
m_archiveHandle = zip_open(m_archive.c_str(), ZIP_CREATE, &error);
if(! m_archiveHandle)
throw FileAccessFailed(m_archive, "Failed to open zip archive.");
// delete all files in the archive
int numFiles = zip_get_num_files(m_archiveHandle);
for(int i = 0; i < numFiles; ++i)
{
if(zip_delete(m_archiveHandle, i) < 0)
throw FileAccessFailed(m_archive, "Failed to delete files in zip archive.");
}
}
/*************************************************
Function: readDexFile
Descroption:
Input:
1.zip* z
2.filename
3.char* buf
Output:
Return:
Other:
*************************************************/
long readDexFile(struct zip* z, char* filename, unsigned char** buf)
{
int i;
long ReadNum = 0;
struct zip_stat fstat;
if(z != NULL && NULL != buf)
{
zip_stat_init(&fstat);
int c = zip_get_num_files(z);
if(c > 0)
{
for (i = 0 ; i < c; i++)
{
const char* name = zip_get_name(z, i, 0);
if(0 == strcmp(name,filename))
{
zip_stat(z, name,0,&fstat);
//LOGI("File %i:%s Size1: %lld Size2: %lld\n", i,fstat.name,fstat.size ,fstat.comp_size);
struct zip_file* file = zip_fopen(z, filename, 0);
if (file)
{
*buf =(unsigned char *)malloc(fstat.size+1);
memset(*buf,0,(fstat.size+1));
ReadNum = zip_fread(file, *buf,fstat.size);
zip_fclose(file);
}
break;
}
}
}
}
else
{
return 0;
}
return ReadNum;
}
static YogVal
compress(YogEnv* env, YogVal self, YogVal pkg, YogVal args, YogVal kw, YogVal block)
{
SAVE_ARGS5(env, self, pkg, args, kw, block);
YogVal path = YUNDEF;
YogVal files = YUNDEF;
PUSH_LOCALS2(env, path, files);
YogCArg params[] = { { "path", &path }, { "*", &files }, { NULL, NULL } };
YogGetArgs_parse_args(env, "compress", params, args, kw);
if (!IS_PTR(path) || (BASIC_OBJ_TYPE(path) != TYPE_STRING)) {
YogError_raise_TypeError(env, "path must be String");
}
struct zip* archive = open_zip(env, pkg, path, ZIP_CREATE);
int n = zip_get_num_files(archive);
int i;
for (i = 0; i < n; i++) {
if (zip_delete(archive, i) != 0) {
raise_ZipError(env, pkg, zip_strerror(archive));
}
}
uint_t size = YogArray_size(env, files);
uint_t j;
for (j = 0; j < size; j++) {
YogHandle* name = VAL2HDL(env, YogArray_at(env, files, j));
YogMisc_check_String(env, name, "Filename");
YogVal bin = YogString_to_bin_in_default_encoding(env, name);
const char* fname = BINARY_CSTR(bin);
struct zip_source* source = zip_source_file(archive, fname, 0, 0);
if (source == NULL) {
raise_ZipError(env, pkg, zip_strerror(archive));
}
if (zip_add(archive, fname, source) < 0) {
raise_ZipError(env, pkg, zip_strerror(archive));
}
}
close_zip(env, pkg, archive);
RETURN(env, YNIL);
}
static VALUE zipruby_archive_each(VALUE self) {
struct zipruby_archive *p_archive;
int i, num_files;
Data_Get_Struct(self, struct zipruby_archive, p_archive);
Check_Archive(p_archive);
num_files = zip_get_num_files(p_archive->archive);
for (i = 0; i < num_files; i++) {
VALUE file;
int status;
file = rb_funcall(File, rb_intern("new"), 2, self, INT2NUM(i));
rb_protect(rb_yield, file, &status);
rb_funcall(file, rb_intern("close"), 0);
if (status != 0) {
rb_jump_tag(status);
}
}
return Qnil;
}
Handle<Value> ZipFile::New(const Arguments& args) {
HandleScope scope;
if (!args.IsConstructCall())
return ThrowException(String::New("Cannot call constructor as function, you need to use 'new' keyword"));
if (args.Length() != 1 || !args[0]->IsString())
return ThrowException(Exception::TypeError(
String::New("first argument must be a path to a zipfile")));
std::string input_file = TOSTR(args[0]);
struct zip *za;
int err;
char errstr[1024];
if ((za = zip_open(input_file.c_str(), 0, &err)) == NULL) {
zip_error_to_str(errstr, sizeof(errstr), err, errno);
std::stringstream s;
s << "cannot open file: " << input_file << " error: " << errstr << "\n";
return ThrowException(Exception::Error(
String::New(s.str().c_str())));
}
ZipFile* zf = new ZipFile(input_file);
int num = zip_get_num_files(za);
zf->names_.reserve(num);
int i = 0;
for (i = 0; i < num; i++) {
struct zip_stat st;
zip_stat_index(za, i, 0, &st);
zf->names_.push_back(st.name);
}
zf->archive_ = za;
zf->Wrap(args.This());
return args.This();
}
RList * r_io_zip_get_files(char *archivename, ut32 perm, int mode, int rw) {
struct zip *zipArch = r_io_zip_open_archive (archivename, perm, mode, rw);
ut64 num_entries = 0, i = 0;
RList *files = NULL;
struct zip_stat sb;
char *name;
if (zipArch) {
files = r_list_newf (free);
if (!files) {
zip_close (zipArch);
return NULL;
}
num_entries = zip_get_num_files (zipArch);
for (i = 0; i < num_entries; i++) {
zip_stat_init (&sb);
zip_stat_index (zipArch, i, 0, &sb);
if ((name = strdup (sb.name))) {
r_list_append (files, name);
}
}
}
zip_close (zipArch);
return files;
}
bool QgsZipUtils::unzip( const QString &zipFilename, const QString &dir, QStringList &files )
{
files.clear();
if ( !QFileInfo::exists( zipFilename ) )
{
QgsMessageLog::logMessage( QObject::tr( "Error zip file does not exist: '%1'" ).arg( zipFilename ) );
return false;
}
else if ( zipFilename.isEmpty() )
{
QgsMessageLog::logMessage( QObject::tr( "Error zip filename is empty" ) );
return false;
}
else if ( !QDir( dir ).exists( dir ) )
{
QgsMessageLog::logMessage( QObject::tr( "Error output dir does not exist: '%1'" ).arg( dir ) );
return false;
}
else if ( !QFileInfo( dir ).isDir() )
{
QgsMessageLog::logMessage( QObject::tr( "Error output dir is not a directory: '%1'" ).arg( dir ) );
return false;
}
else if ( !QFileInfo( dir ).isWritable() )
{
QgsMessageLog::logMessage( QObject::tr( "Error output dir is not writable: '%1'" ).arg( dir ) );
return false;
}
int rc = 0;
const QByteArray fileNamePtr = zipFilename.toUtf8();
struct zip *z = zip_open( fileNamePtr.constData(), ZIP_CHECKCONS, &rc );
if ( rc == ZIP_ER_OK && z )
{
int count = zip_get_num_files( z );
if ( count != -1 )
{
struct zip_stat stat;
for ( int i = 0; i < count; i++ )
{
zip_stat_index( z, i, 0, &stat );
size_t len = stat.size;
struct zip_file *file = zip_fopen_index( z, i, 0 );
std::unique_ptr< char[] > buf( new char[len] );
if ( zip_fread( file, buf.get(), len ) != -1 )
{
QString fileName( stat.name );
QFileInfo newFile( QDir( dir ), fileName );
// Create path for a new file if it does not exist.
if ( !newFile.absoluteDir().exists() )
{
if ( !QDir( dir ).mkpath( newFile.absolutePath() ) )
QgsMessageLog::logMessage( QObject::tr( "Failed to create a subdirectory %1/%2" ).arg( dir ).arg( fileName ) );
}
QFile outFile( newFile.absoluteFilePath() );
if ( !outFile.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
{
QgsMessageLog::logMessage( QObject::tr( "Could not write to %1" ).arg( newFile.absoluteFilePath() ) );
}
else
{
outFile.write( buf.get(), len );
}
zip_fclose( file );
files.append( newFile.absoluteFilePath() );
}
else
{
zip_fclose( file );
QgsMessageLog::logMessage( QObject::tr( "Error reading file: '%1'" ).arg( zip_strerror( z ) ) );
return false;
}
}
}
else
{
zip_close( z );
QgsMessageLog::logMessage( QObject::tr( "Error getting files: '%1'" ).arg( zip_strerror( z ) ) );
return false;
}
zip_close( z );
}
else
{
QgsMessageLog::logMessage( QObject::tr( "Error opening zip archive: '%1' (Error code: %2)" ).arg( z ? zip_strerror( z ) : zipFilename, rc ) );
return false;
}
return true;
}
static int
merge_zip(struct zip *za, const char *tname, const char *sname,
struct zip **zsp)
{
struct zip *zs;
struct zip_source *source;
int i, idx, err;
char errstr[1024];
const char *fname;
if ((zs=zip_open(sname, 0, &err)) == NULL) {
zip_error_to_str(errstr, sizeof(errstr), err, errno);
fprintf(stderr, "%s: cannot open zip archive `%s': %s\n",
prg, sname, errstr);
return -1;
}
for (i=0; i<zip_get_num_files(zs); i++) {
fname = zip_get_name(zs, i, 0);
if ((idx=zip_name_locate(za, fname, name_flags)) != -1) {
switch (confirm_replace(za, tname, idx, zs, sname, i)) {
case 0:
break;
case 1:
if ((source=zip_source_zip(za, zs, i, 0, 0, 0)) == NULL
|| zip_replace(za, idx, source) < 0) {
zip_source_free(source);
fprintf(stderr,
"%s: cannot replace `%s' in `%s': %s\n",
prg, fname, tname, zip_strerror(za));
return -1;
}
break;
case -1:
zip_close(zs);
return -1;
default:
fprintf(stderr, "%s: internal error: "
"unexpected return code from confirm (%d)\n",
prg, err);
zip_close(zs);
return -1;
}
}
else {
if ((source=zip_source_zip(za, zs, i, 0, 0, 0)) == NULL
|| zip_add(za, fname, source) < 0) {
zip_source_free(source);
fprintf(stderr,
"%s: cannot add `%s' to `%s': %s\n",
prg, fname, tname, zip_strerror(za));
zip_close(zs);
return -1;
}
}
}
*zsp = zs;
return 0;
}
AbstractFSProvider::status_t ZIPProvider::ZIPHandle::dir(
const std::string & localDirectory,
std::list<FileName> & result,
const uint8_t flags) {
int num = zip_get_num_files(handle);
if (num == -1) {
WARN(zip_strerror(handle));
return FAILURE;
}
struct zip_stat sb;
zip_stat_init(&sb);
// Iterate over indices.
for (int i = 0; i < num; ++i) {
if (zip_stat_index(handle, i, 0, &sb) == -1) {
WARN(zip_strerror(handle));
return FAILURE;
}
FileName entryFileName(sb.name);
// Determine if the entry is a file or a directory.
if (entryFileName.getFile().empty()) {
if(!(flags & FileUtils::DIR_DIRECTORIES)) {
continue;
}
if (!(flags & FileUtils::DIR_RECURSIVE)) {
std::string entryDirectory = entryFileName.getDir();
if(entryDirectory == localDirectory) {
continue;
}
if(entryDirectory.back() == '/') {
entryDirectory.resize(entryDirectory.size() - 1);
}
const auto slashPos = entryDirectory.find_last_of('/');
if(slashPos != std::string::npos) {
entryDirectory = entryDirectory.substr(0, slashPos + 1);
} else {
entryDirectory.clear();
}
// Compare the parent directory of the directory with the requested localDirectory.
if(entryDirectory != localDirectory) {
continue;
}
}
} else {
if(!(flags & FileUtils::DIR_FILES)) {
continue;
}
// Compare the directory of the file with the requested localDirectory.
if (!(flags & FileUtils::DIR_RECURSIVE) && entryFileName.getDir() != localDirectory) {
continue;
}
}
// Check for hidden files beginning with '.' (files only).
if (entryFileName.getFile().front() == '.' && !(flags & FileUtils::DIR_HIDDEN_FILES)) {
continue;
}
FileName f;
f.setFSName(archiveRoot.getFSName());
f.setDir(archiveRoot.getDir() + entryFileName.getDir());
f.setFile(entryFileName.getFile());
result.push_back(f);
}
return OK;
}
bool FlpImport::tryZIPImport( trackContainer * _tc )
{
// see if the file is a zip file
closeFile();
const QFile &thefile = file();
int err = 0;
struct zip *zfile = zip_open(qPrintable(thefile.fileName()), 0, &err);
if( zfile == NULL )
{
if( err == ZIP_ER_NOZIP )
{
printf("flp import (zip): not a valid zip file\n");
}
else if( err == ZIP_ER_OPEN )
{
printf("flp import (zip): error opening file\n");
}
else if( err == ZIP_ER_READ || err == ZIP_ER_SEEK )
{
printf("flp import (zip): error reading file\n");
}
else
{
printf("flp import (zip): unknown error opening zip file\n");
}
return false;
}
// valid zip file
// get temporary directory
QString tmpName;
{
QTemporaryFile qtmp;
if( qtmp.open() )
{
tmpName = qtmp.fileName();
}
else
{
zip_close(zfile);
printf("flp import (zip): error getting temporary folder\n");
return false;
}
}
QDir tmpDir = QDir::temp();
tmpDir.mkdir(tmpName);
tmpDir.cd(tmpName);
// unzip everything to the temp folder
int buf_size = getpagesize();
char buf[buf_size];
int numFiles = zip_get_num_files(zfile);
int i;
bool foundFLP = false;
QString flpFile = "";
for( i=0; i<numFiles; ++i )
{
const char* fileName = zip_get_name(zfile, i, 0);
if( fileName != NULL )
{
struct zip_file *unzipFile = zip_fopen_index(zfile, i, 0);
if( unzipFile != NULL )
{
// we have a handle to read, now get a handle to the outfile
QFile out(tmpDir.absolutePath() + QDir::separator() +
fileName);
out.open(QIODevice::WriteOnly);
// ok we have handles on both, now do buffered writing
bool readErr = false;
while(true)
{
// read into buffer
int numRead = zip_fread(unzipFile, buf, buf_size);
if( numRead == -1 )
{
readErr = true;
printf("flp import (zip): error while reading %s "
"from zip file\n", fileName);
break;
}
out.write( buf, numRead );
if( numRead < buf_size ) break;
}
// we successfully read this file, check if it is
// the .flp file
QString qFileName(fileName);
if( qFileName.endsWith(".flp") )
{
foundFLP = true;
flpFile = out.fileName();
}
// clean up
out.close();
zip_fclose(unzipFile);
}
else
{
printf("flp import (zip): unable to get %s out of %s\n",
fileName, qPrintable(thefile.fileName()) );
}
}
}
zip_close(zfile);
// make sure there was a .flp file in the archive
if( ! foundFLP )
{
printf("flp import (zip): no .flp file found in archive\n");
return false;
}
// use the flp_import plugin to load the .flp file
// which was extracted to the temp dir
setFile(flpFile);
m_fileBase = QFileInfo( flpFile ).path();
return tryFLPImport( _tc );
}
static VALUE zipruby_archive_update(int argc, VALUE *argv, VALUE self) {
struct zipruby_archive *p_archive, *p_srcarchive;
VALUE srcarchive, flags;
int i, num_files, i_flags = 0;
rb_scan_args(argc, argv, "11", &srcarchive, &flags);
if (!rb_obj_is_instance_of(srcarchive, Archive)) {
rb_raise(rb_eTypeError, "wrong argument type %s (expected Zip::Archive)", rb_class2name(CLASS_OF(srcarchive)));
}
if (!NIL_P(flags)) {
i_flags = NUM2INT(flags);
}
Data_Get_Struct(self, struct zipruby_archive, p_archive);
Check_Archive(p_archive);
Data_Get_Struct(srcarchive, struct zipruby_archive, p_srcarchive);
Check_Archive(p_srcarchive);
num_files = zip_get_num_files(p_srcarchive->archive);
for (i = 0; i < num_files; i++) {
struct zip_source *zsource;
struct zip_file *fzip;
struct zip_stat sb;
char *buf;
const char *name;
int index, error;
zip_stat_init(&sb);
if (zip_stat_index(p_srcarchive->archive, i, 0, &sb)) {
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_srcarchive->archive));
}
if ((buf = malloc(sb.size)) == NULL) {
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(rb_eRuntimeError, "Update archive failed: Cannot allocate memory");
}
fzip = zip_fopen_index(p_srcarchive->archive, i, 0);
if (fzip == NULL) {
free(buf);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_srcarchive->archive));
}
if (zip_fread(fzip, buf, sb.size) == -1) {
free(buf);
zip_fclose(fzip);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_file_strerror(fzip));
}
if ((error = zip_fclose(fzip)) != 0) {
char errstr[ERRSTR_BUFSIZE];
free(buf);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
zip_error_to_str(errstr, ERRSTR_BUFSIZE, error, errno);
rb_raise(Error, "Update archive failed: %s", errstr);
}
if ((zsource = zip_source_buffer(p_archive->archive, buf, sb.size, 1)) == NULL) {
free(buf);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_archive->archive));
}
if ((name = zip_get_name(p_srcarchive->archive, i, 0)) == NULL) {
zip_source_free(zsource);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_srcarchive->archive));
}
index = zip_name_locate(p_archive->archive, name, i_flags);
if (index >= 0) {
if (zip_replace(p_archive->archive, i, zsource) == -1) {
zip_source_free(zsource);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_archive->archive));
}
} else {
if (zip_add(p_archive->archive, name, zsource) == -1) {
zip_source_free(zsource);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_archive->archive));
}
}
}
return Qnil;
}
int cepgdata2xmltv::Process(int argc, char *argv[])
{
FILE *f=fopen("/var/lib/epgsources/epgdata2xmltv","r");
if (!f)
{
esyslog("failed to open epgdata2xmltv config");
return 1;
}
char *line=NULL,*lptr=NULL;
size_t size;
if (getline(&line,&size,f)==(ssize_t) -1)
{
fclose(f);
esyslog("failed to read epgdata2xmltv config");
return 1;
}
if (getline(&line,&size,f)==(ssize_t) -1)
{
fclose(f);
if (line) free(line);
esyslog("failed to read epgdata2xmltv config");
return 1;
}
char *sc=strchr(line,';');
if (sc)
{
*sc=0;
sc++;
}
else
{
sc=line;
}
int daysmax=atoi(sc);
if (daysmax<0) daysmax=1;
int daysinadvance=atoi(argv[1]);
if (daysinadvance<0) daysinadvance=1;
if (daysinadvance>daysmax) daysinadvance=daysmax;
bool head=false;
char *xmlmem=NULL;
time_t t=time(NULL);
int carg=3;
if (!strcmp(argv[3],"1") || !strcmp(argv[3],"0")) carg++;
for (int day=0; day<=daysinadvance; day++)
{
time_t td=t+(day*86400);
struct tm *tm;
tm=localtime(&td);
char vgl[10];
sprintf(vgl,"%04i%02i%02i",tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday);
char *dest=NULL;
if (asprintf(&dest,"/tmp/%s_epgdata.zip",vgl)==-1)
{
esyslog("failed to allocate string");
continue;
}
bool ok=false;
do
{
bool offline=true;
struct stat statbuf;
if (stat(dest,&statbuf)==-1)
{
if (Fetch(dest,argv[2],day))
{
ok=true;
break;
}
offline=false;
}
struct zip *zip=zip_open(dest,0,NULL);
if (!zip)
{
if (offline)
{
if (unlink(dest)==-1)
{
esyslog("cannot unlink %s",dest);
ok=true;
break;
}
continue;
}
esyslog("failed to open %s",dest);
ok=true;
break;
}
int i=zip_name_locate(zip,"qy.dtd",ZIP_FL_NOCASE);
if (i==-1)
{
if (offline)
{
if (unlink(dest)==-1)
{
esyslog("cannot unlink %s",dest);
ok=true;
break;
}
continue;
}
esyslog("failed read qy.dtd in %s",dest);
ok=true;
break;
}
struct zip_file *zfile=zip_fopen_index(zip,i,0);
if (!zfile)
{
if (offline)
{
if (unlink(dest)==-1)
{
esyslog("cannot unlink %s",dest);
ok=true;
break;
}
continue;
}
esyslog("failed to read qy.dtd from %s",dest);
ok=true;
break;
}
struct zip_stat sb;
memset(&sb,0,sizeof(sb));
if (zip_stat_index(zip,i,ZIP_FL_UNCHANGED,&sb)==-1)
{
if (offline)
{
if (unlink(dest)==-1)
{
zip_fclose(zfile);
esyslog("cannot unlink %s",dest);
ok=true;
break;
}
continue;
}
zip_fclose(zfile);
esyslog("failed to stat qy.dtd in %s",dest);
ok=true;
break;
}
if (sizeof(sb.size>4)) sb.size &= 0x00FFFFFF; // just to be sure
if (dtdmem) {
free(dtdmem);
dtdmem=NULL;
}
dtdmem=(char *) malloc(sb.size+1);
int size=zip_fread(zfile,dtdmem,sb.size);
if (size!=sb.size)
{
zip_fclose(zfile);
esyslog("failed to read qy.dtd from %s",dest);
ok=true;
break;
}
dtdmem[size]=0;
zip_fclose(zfile);
int entries=zip_get_num_files(zip);
for (int i=0; i<entries; i++)
{
const char *name=zip_get_name(zip,i,0);
if (strstr(name,"xml"))
{
// check date of xml
if (strstr(name,vgl))
{
struct zip_file *zfile=zip_fopen_index(zip,i,0);
if (!zfile)
{
if (offline)
{
if (unlink(dest)==-1)
{
esyslog("cannot unlink %s",dest);
ok=true;
break;
}
continue;
}
esyslog("failed to read %s from %s",name,dest);
ok=true;
break;
}
struct zip_stat sb;
memset(&sb,0,sizeof(sb));
if (zip_stat_index(zip,i,ZIP_FL_UNCHANGED,&sb)==-1)
{
if (offline)
{
if (unlink(dest)==-1)
{
esyslog("cannot unlink %s",dest);
ok=true;
break;
}
continue;
}
esyslog("failed to stat %s in %s",name,dest);
ok=true;
break;
}
if (sizeof(sb.size>4)) sb.size &= 0x00FFFFFF; // just to be sure
xmlmem=(char *) malloc(sb.size+1);
int size=zip_fread(zfile,xmlmem,sb.size);
if (size!=sb.size)
{
zip_fclose(zfile);
free(xmlmem);
xmlmem=NULL;
esyslog("failed to read %s from %s",name,dest);
ok=true;
break;
}
xmlmem[size]=0;
xmlmem=strreplace(xmlmem,"iso-8859-1","Windows-1252");
zip_fclose(zfile);
ok=true;
break;
}
}
}
if (!strcmp(argv[3],"1")) {
int entries=zip_get_num_files(zip);
for (int i=0; i<entries; i++)
{
const char *name=zip_get_name(zip,i,0);
if (strstr(name,"jpg")) {
char *destjpg;
if (asprintf(&destjpg,"/var/lib/epgsources/epgdata2xmltv-img/%s",name)!=-1) {
struct stat statbuf;
if (stat(destjpg,&statbuf)==-1) {
struct zip_file *zfile=zip_fopen_index(zip,i,0);
if (zfile)
{
struct zip_stat sb;
memset(&sb,0,sizeof(sb));
if (zip_stat_index(zip,i,ZIP_FL_UNCHANGED,&sb)!=-1) {
if (sizeof(sb.size>4)) sb.size &= 0x00FFFFFF; // just to be sure
char *jpg=(char *) malloc(sb.size+1);
if (jpg) {
int size=zip_fread(zfile,jpg,sb.size);
if (size==sb.size) {
FILE *j=fopen(destjpg,"w+");
if (j) {
fwrite(jpg,size,1,j);
fclose(j);
}
}
}
}
zip_fclose(zfile);
}
}
free(destjpg);
}
}
}
}
zip_close(zip);
if (!ok)
{
if (offline)
{
if (unlink(dest)==-1)
{
ok=true;
break;
}
continue;
}
else
{
esyslog("found no valid data in %s",dest);
if (xmlmem) free(xmlmem);
xmlmem=NULL;
ok=true;
break;
}
}
}
while (ok==false);
free(dest);
if (!line)
{
line=(char *) malloc(81);
size=80;
}
if (!xmlmem) continue;
long offset=ftell(f);
xmlDocPtr pxmlDoc;
if (!pxsltStylesheet) LoadXSLT();
int xmlsize=strlen(xmlmem);
if ((pxmlDoc=xmlParseMemory(xmlmem,xmlsize))==NULL)
{
EncaAnalyser analyser=enca_analyser_alloc("__");
if (analyser) {
EncaEncoding encoding=enca_analyse_const(analyser, (unsigned char *) xmlmem,xmlsize);
const char *cs=enca_charset_name(encoding.charset, ENCA_NAME_STYLE_ICONV);
if (cs) {
if (!strcmp(cs,"UTF-8")) {
xmlmem=strreplace(xmlmem,"Windows-1252","UTF-8");
} else {
esyslog("enca returned %s, please report!",cs);
}
}
enca_analyser_free(analyser);
}
string s = xmlmem;
int reps=pcrecpp::RE("&(?![a-zA-Z]{1,8};)").GlobalReplace("%amp;",&s);
if (reps) {
xmlmem = (char *)realloc(xmlmem, s.size()+1);
xmlsize = s.size();
strcpy(xmlmem,s.c_str());
}
if ((pxmlDoc=xmlParseMemory(xmlmem,xmlsize))==NULL)
{
esyslog("failed parsing xml");
free(xmlmem);
xmlmem=NULL;
continue;
}
}
for (;;)
{
lptr=line+1;
line[0]=' ';
if (getline(&lptr,&size,f)==-1) break;
char *channel=line;
char *sc=strchr(channel,';');
if (sc) *sc=0;
bool use=false;
for (int i=carg; i<argc; i++)
{
if (!strcasecmp(lptr,argv[i]))
{
use=true;
break;
}
}
if (use)
{
if (!head)
{
printf("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
printf("<tv generator-info-name=\"epgdata2xmltv\">\n");
for (int i=carg; i<argc; i++)
{
printf("<channel id=\"%s\">\n",argv[i]);
printf("<display-name lang=\"de\">%s</display-name>\n",argv[i]);
printf("</channel>\n");
}
head=true;
}
int num=atoi(sc+1);
if (num>0)
{
char *channelnum=strdup(sc+1);
char *lf=strchr(channelnum,10);
if (lf) *lf=0;
channel[0]='"';
*sc++='"';
*sc=0;
const char *params[5] =
{
"channelid", channel, "channelnum",channelnum,NULL
};
Translate(pxmlDoc,params);
if (channelnum) free(channelnum);
}
}
}
xmlFreeDoc (pxmlDoc);
fseek(f,offset,SEEK_SET);
if (dtdmem) {
free(dtdmem);
dtdmem=NULL;
}
if (xmlmem) {
free(xmlmem);
xmlmem=NULL;
}
}
if (line) free(line);
fclose(f);
if (head) printf("</tv>\n");
return head ? 0 : 1;
}
