static int add_from_zip(int argc, char *argv[]) { zip_uint64_t idx, start; zip_int64_t len; int err; zip_source_t *zs; /* add from another zip file */ idx = strtoull(argv[2], NULL, 10); start = strtoull(argv[3], NULL, 10); len = strtoll(argv[4], NULL, 10); if ((z_in[z_in_count]=zip_open(argv[1], ZIP_CHECKCONS, &err)) == NULL) { zip_error_t error; zip_error_init_with_code(&error, err); fprintf(stderr, "can't open zip archive '%s': %s\n", argv[1], zip_error_strerror(&error)); zip_error_fini(&error); return -1; } if ((zs=zip_source_zip(za, z_in[z_in_count], idx, 0, start, len)) == NULL) { fprintf(stderr, "error creating file source from '%s' index '%" PRIu64 "': %s\n", argv[1], idx, zip_strerror(za)); zip_close(z_in[z_in_count]); return -1; } if (zip_add(za, argv[0], zs) == -1) { fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za)); zip_source_free(zs); zip_close(z_in[z_in_count]); return -1; } z_in_count++; return 0; }
static int add_file(int argc, char *argv[]) { zip_source_t *zs; zip_uint64_t start = strtoull(argv[2], NULL, 10); zip_int64_t len = strtoll(argv[3], NULL, 10); if (strcmp(argv[1], "/dev/stdin") == 0) { if ((zs=zip_source_filep(za, stdin, start, len)) == NULL) { fprintf(stderr, "can't create zip_source from stdin: %s\n", zip_strerror(za)); return -1; } } else { if ((zs=zip_source_file(za, argv[1], start, len)) == NULL) { fprintf(stderr, "can't create zip_source from file: %s\n", zip_strerror(za)); return -1; } } if (zip_add(za, argv[0], zs) == -1) { zip_source_free(zs); fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za)); return -1; } return 0; }
bool zipobject::writeData(const QByteArray& data,const QString& inZipPath){ TEST_ZIP; int length=data.length(); void* p=new char[length+1]; // 此处不得不复制。 // 由于 libzip 只会在 close 的时候才会真正将数据写入zip文件 // 如果不复制,写入数据时 data 已经析构,数据内容全部为空 memcpy(p,data.constData(),length); zip_source* pSource = zip_source_buffer(m_zip,p,length,1); if(NULL == pSource){ const char* pStr = zip_strerror(m_zip); qDebug()<<"create source failed : "<<pStr; return false; }else{ int index = zip_name_locate(m_zip,getCharPtr(inZipPath),0); if( -1 == index ){ int rAdd = zip_add(m_zip,getCharPtr(inZipPath),pSource); if( -1 == rAdd ){ qDebug()<<"add source failed : "<<zip_strerror(m_zip); } return -1 == rAdd ; }else{ int rReplace = zip_replace(m_zip,index,pSource); if( -1 == rReplace ){ qDebug()<<"replace source failed : "<<zip_strerror(m_zip); } return -1 == rReplace ; } } }
static VALUE zipruby_archive_add_buffer(VALUE self, VALUE name, VALUE source) { struct zipruby_archive *p_archive; struct zip_source *zsource; char *data; size_t len; Check_Type(name, T_STRING); Check_Type(source, T_STRING); Data_Get_Struct(self, struct zipruby_archive, p_archive); Check_Archive(p_archive); len = RSTRING_LEN(source); if ((data = malloc(len)) == NULL) { rb_raise(rb_eRuntimeError, "Add file failed: Cannot allocate memory"); } memset(data, 0, len); memcpy(data, RSTRING_PTR(source), len); if ((zsource = zip_source_buffer(p_archive->archive, data, len, 1)) == NULL) { free(data); rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive)); } if (zip_add(p_archive->archive, RSTRING_PTR(name), zsource) == -1) { zip_source_free(zsource); zip_unchange_all(p_archive->archive); zip_unchange_archive(p_archive->archive); rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive)); } return Qnil; }
static VALUE zipruby_archive_add_file(int argc, VALUE *argv, VALUE self) { VALUE name, fname; struct zipruby_archive *p_archive; struct zip_source *zsource; rb_scan_args(argc, argv, "11", &name, &fname); if (NIL_P(fname)) { fname = name; name = Qnil; } Check_Type(fname, T_STRING); if (NIL_P(name)) { name = rb_funcall(rb_cFile, rb_intern("basename"), 1, fname); } Check_Type(name, T_STRING); Data_Get_Struct(self, struct zipruby_archive, p_archive); Check_Archive(p_archive); if ((zsource = zip_source_file(p_archive->archive, RSTRING_PTR(fname), 0, -1)) == NULL) { rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive)); } if (zip_add(p_archive->archive, RSTRING_PTR(name), zsource) == -1) { zip_source_free(zsource); zip_unchange_all(p_archive->archive); zip_unchange_archive(p_archive->archive); rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive)); } return Qnil; }
int r_io_zip_flush_file(RIOZipFileObj *zfo) { int res = false; struct zip * zipArch; if (!zfo) { return res; } zipArch = r_io_zip_open_archive ( zfo->archivename, zfo->perm, zfo->mode, zfo->rw); if (!zipArch) { return res; } struct zip_source *s = zip_source_buffer (zipArch, zfo->b->buf, zfo->b->length, 0); if (s && zfo->entry != -1) { if (zip_replace(zipArch, zfo->entry, s) == 0) { res = true; } } else if (s && zfo->name) { if (zip_add (zipArch, zfo->name, s) == 0) { zfo->entry = zip_name_locate (zipArch, zfo->name, 0); res = true; } } // s (zip_source) is freed when the archive is closed, i think - dso zip_close (zipArch); if (s) { zip_source_free (s); } return res; }
int r_io_zip_flush_file(RIOZipFileObj *zip_file_obj) { int result = R_FALSE; struct zip * zipArch = r_io_zip_open_archive(zip_file_obj->archivename, zip_file_obj->flags, zip_file_obj->mode, zip_file_obj->rw); if (!zipArch) { return result; } if (zip_file_obj) { struct zip_source *s = zip_source_buffer(zipArch, zip_file_obj->b, zip_file_obj->b->length, 0); if (s && zip_file_obj->entry != -1) { if (zip_replace(zipArch, zip_file_obj->entry, s) == 0) result = R_TRUE; }else if (s && zip_file_obj->name) { if (zip_add(zipArch, zip_file_obj->name, s) == 0) { zip_file_obj->entry = zip_name_locate(zipArch, zip_file_obj->name, 0); result = R_TRUE; } } if (s) zip_source_free(s); } if (zipArch) zip_close(zipArch); return result; }
bool add_to_zip(const char *archive, const char *file, const char *name) { struct zip *za; struct zip_source *zs; int err; if ((za=zip_open(archive, ZIP_CREATE, &err)) == NULL) { return false; } if ((zs=zip_source_file(za, file, 0, -1)) == NULL) { return false; } if (zip_add(za, name, zs) == -1) { zip_source_free(zs); return false; } if (zip_close(za) == -1) { return false; } return true; }
int main(int argc, char *argv[]) { const char *archive; const char *file; const char *name; zip_t *za; zip_source_t *zs; int err; FILE *fp; prg = argv[0]; if (argc != 3) { fprintf(stderr, "usage: %s archive file\n", prg); return 1; } archive = argv[1]; file = argv[2]; if ((za=zip_open(archive, ZIP_CREATE, &err)) == NULL) { zip_error_t error; zip_error_init_with_code(&error, err); fprintf(stderr, "%s: can't open zip archive '%s': %s\n", prg, archive, zip_error_strerror(&error)); zip_error_fini(&error); return 1; } if ((fp=fopen(file, "r")) == NULL) { fprintf(stderr, "%s: can't open input file '%s': %s\n", prg, file, strerror(errno)); return 1; } if ((zs=zip_source_filep(za, fp, 0, -1)) == NULL) { fprintf(stderr, "%s: error creating file source for '%s': %s\n", prg, file, zip_strerror(za)); return 1; } if ((name=strrchr(file, '/')) == NULL) name = file; if (zip_add(za, name, zs) == -1) { zip_source_free(zs); fprintf(stderr, "%s: can't add file '%s': %s\n", prg, file, zip_strerror(za)); return 1; } if (zip_close(za) == -1) { fprintf(stderr, "%s: can't close zip archive '%s': %s\n", prg, archive, zip_strerror(za)); return 1; } return 0; }
int main(int argc, char *argv[]) { int fail, ze; struct zip *z; struct zip_source *zs; char *archive; char errstr[1024]; fail = 0; prg = argv[0]; if (argc != 2) { fprintf(stderr, "usage: %s archive\n", prg); return 1; } archive = argv[1]; if ((z=zip_open(archive, 0, &ze)) == NULL) { zip_error_to_str(errstr, sizeof(errstr), ze, errno); printf("%s: opening zip archive ``%s'' failed: %s\n", prg, archive, errstr); return 1; } fail += do_read(z, "storedok", 0, WHEN_NEVER, 0, 0); fail += do_read(z, "deflateok", 0, WHEN_NEVER, 0, 0); fail += do_read(z, "storedcrcerror", 0, WHEN_READ, ZIP_ER_CRC, 0); fail += do_read(z, "deflatecrcerror", 0, WHEN_READ, ZIP_ER_CRC, 0); fail += do_read(z, "deflatezliberror", 0, WHEN_READ, ZIP_ER_ZLIB, -3); fail += do_read(z, NULL, 0, WHEN_OPEN, ZIP_ER_INVAL, 0); fail += do_read(z, "nosuchfile", 0, WHEN_OPEN, ZIP_ER_NOENT, 0); fail += do_read(z, "deflatezliberror", ZIP_FL_COMPRESSED, WHEN_NEVER, 0,0); fail += do_read(z, "deflatecrcerror", ZIP_FL_COMPRESSED, WHEN_NEVER, 0, 0); fail += do_read(z, "storedcrcerror", ZIP_FL_COMPRESSED, WHEN_READ, ZIP_ER_CRC, 0); fail += do_read(z, "storedok", ZIP_FL_COMPRESSED, WHEN_NEVER, 0, 0); zs = zip_source_buffer(z, "asdf", 4, 0); zip_replace(z, zip_name_locate(z, "storedok", 0), zs); fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0); fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0); zip_delete(z, zip_name_locate(z, "storedok", 0)); fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_NOENT, 0); fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0); zs = zip_source_buffer(z, "asdf", 4, 0); zip_add(z, "new_file", zs); fail += do_read(z, "new_file", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0); zip_unchange_all(z); if (zip_close(z) == -1) { fprintf(stderr, "%s: can't close zip archive `%s'\n", prg, archive); return 1; } exit(fail ? 1 : 0); }
bool QgsZipUtils::zip( const QString &zipFilename, const QStringList &files ) { if ( zipFilename.isEmpty() ) { QgsMessageLog::logMessage( QObject::tr( "Error zip filename is empty" ) ); return false; } int rc = 0; const QByteArray fileNamePtr = zipFilename.toUtf8(); struct zip *z = zip_open( fileNamePtr.constData(), ZIP_CREATE, &rc ); if ( rc == ZIP_ER_OK && z ) { for ( const auto &file : files ) { QFileInfo fileInfo( file ); if ( !fileInfo.exists() ) { QgsMessageLog::logMessage( QObject::tr( "Error input file does not exist: '%1'" ).arg( file ) ); zip_close( z ); return false; } const QByteArray fileNamePtr = file.toUtf8(); zip_source *src = zip_source_file( z, fileNamePtr.constData(), 0, 0 ); if ( src ) { const QByteArray fileInfoPtr = fileInfo.fileName().toUtf8(); #if LIBZIP_VERSION_MAJOR < 1 int rc = ( int ) zip_add( z, fileInfoPtr.constData(), src ); #else int rc = ( int ) zip_file_add( z, fileInfoPtr.constData(), src, 0 ); #endif if ( rc == -1 ) { QgsMessageLog::logMessage( QObject::tr( "Error adding file '%1': %2" ).arg( file, zip_strerror( z ) ) ); zip_close( z ); return false; } } else { QgsMessageLog::logMessage( QObject::tr( "Error creating data source '%1': %2" ).arg( file, zip_strerror( z ) ) ); zip_close( z ); return false; } } zip_close( z ); } else { QgsMessageLog::logMessage( QObject::tr( "Error creating zip archive '%1': %2" ).arg( zipFilename, zip_strerror( z ) ) ); return false; } return true; }
static VALUE zipruby_archive_add_io(int argc, VALUE *argv, VALUE self) { VALUE name, file, mtime; struct zipruby_archive *p_archive; struct zip_source *zsource; struct read_io *z; rb_scan_args(argc, argv, "11", &name, &file); if (NIL_P(file)) { file = name; name = Qnil; } Check_IO(file); if (NIL_P(name)) { if (rb_obj_is_kind_of(file, rb_cFile)) { name = rb_funcall(rb_cFile, rb_intern("basename"), 1, rb_funcall(file, rb_intern("path"), 0)); } else { rb_raise(rb_eRuntimeError, "Add io failed - %s: Entry name is not given", RSTRING(rb_inspect(file))); } } if (rb_obj_is_kind_of(file, rb_cFile)) { mtime = rb_funcall(file, rb_intern("mtime"), 0); } else { mtime = rb_funcall(rb_cTime, rb_intern("now"), 0); } Data_Get_Struct(self, struct zipruby_archive, p_archive); Check_Archive(p_archive); if ((z = malloc(sizeof(struct read_io))) == NULL) { zip_unchange_all(p_archive->archive); zip_unchange_archive(p_archive->archive); rb_raise(rb_eRuntimeError, "Add io failed - %s: Cannot allocate memory", RSTRING(rb_inspect(file))); } z->io = file; rb_ary_push(p_archive->sources, file); z->mtime = TIME2LONG(mtime); if ((zsource = zip_source_io(p_archive->archive, z)) == NULL) { free(z); rb_raise(Error, "Add io failed - %s: %s", RSTRING(rb_inspect(file)), zip_strerror(p_archive->archive)); } if (zip_add(p_archive->archive, RSTRING_PTR(name), zsource) == -1) { zip_source_free(zsource); zip_unchange_all(p_archive->archive); zip_unchange_archive(p_archive->archive); rb_raise(Error, "Add io failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive)); } return Qnil; }
bool CompressFiles(std::string ZipName, std::vector<std::string>* pFilePaths, std::string* pError) //pointer to a vector of filepath strings to zip into location of ZipName (also a filepath) { #ifdef WIN32 HZIP hz = CreateZip(ZipName.c_str(),0); if (!hz){if (pError) *pError += "Could not create ZIP archive. Aborting\n"; return false;} int NumFiles = pFilePaths->size(); for (int i=0; i<NumFiles; i++){ std::string ThisFilePath = (*pFilePaths)[i]; //extract file name (without path) int StartName = ThisFilePath.find_last_of('/')+1; int EndName = ThisFilePath.size(); std::string Name = ThisFilePath.substr(StartName, EndName-StartName); //remove .tmp from end if it exists... std::string Last4 = Name.substr(Name.size()-4, 4); if (Last4.compare(".tmp")==0) Name = Name.substr(0, Name.size()-4); if(ZipAdd(hz, Name.c_str(), ThisFilePath.c_str()) != ZR_OK){if (pError) *pError += ("Could not add file to ZIP archive. Aborting.\n"); return false;} } if(CloseZip(hz) != ZR_OK){if (pError) *pError += ("Could not close ZIP archive. Aborting.\n"); return false;} return true; #else //Mac/Linux Zip write code remove(ZipName.c_str()); int err; struct zip * hz = zip_open(ZipName.c_str(), ZIP_CREATE, &err); if (!hz){if (pError) *pError += "Could not create ZIP archive. Aborting\n"; return false;} int NumFiles = pFilePaths->size(); for (int i=0; i<NumFiles; i++){ std::string ThisFilePath = (*pFilePaths)[i]; //extract file name (without path) int StartName = ThisFilePath.find_last_of('/')+1; int EndName = ThisFilePath.size(); std::string Name = ThisFilePath.substr(StartName, EndName-StartName); //remove .tmp from end if it exists... std::string Last4 = Name.substr(Name.size()-4, 4); if (Last4.compare(".tmp")==0) Name = Name.substr(0, Name.size()-4); struct zip_source * source = zip_source_file(hz, ThisFilePath.c_str(), 0, 0); if(source == NULL || zip_add(hz, Name.c_str(), source) == -1){if (pError) *pError += ("Could not add file to ZIP archive. Aborting.\n"); return false;} } if (zip_close(hz) != 0) {if(pError) *pError += "Error closing ZIP file.\n"; return false;} return true; #endif }
/* zipfile.addFile(nameInArchive, name, offset, len) */ Handle<Value> ZipFile::Add_File(const Arguments& args) { ZipFile* zf = ObjectWrap::Unwrap<ZipFile>(args.This()); struct zip_source *source; if (zf->Busy()) return ThrowException(Exception::Error(String::New("Zipfile already in use.."))); if (!args[0]->IsString()) return ThrowException(Exception::TypeError( String::New("Argument must be a file name."))); std::string archive_file = TOSTR(args[0]); std::string name; if (args[1]->IsUndefined()) name = archive_file; else if (!args[1]->IsString()) return ThrowException(Exception::TypeError( String::New("Argument must be a file name."))); name = TOSTR(args[1]); zip_int64_t off; if (args[2]->IsUndefined()) off = 0; else off = args[2]->Int32Value(); zip_int64_t len; if (args[3]->IsUndefined()) len = -1; else len = args[3]->Int32Value(); source = zip_source_file(zf->archive, name.c_str(), off, len); if (source == NULL) { std::stringstream s; s << "Error while adding file " << name << " to zip archive: " << zip_strerror(zf->archive) << "\n"; return ThrowException(Exception::Error(String::New(s.str().c_str()))); } int ret = zip_add(zf->archive, archive_file.c_str(), source); if (ret < 0) { zip_source_free(source); std::stringstream s; s << "Error while adding file " << name << " to zip archive: " << zip_strerror(zf->archive) << "\n"; return ThrowException(Exception::Error(String::New(s.str().c_str()))); } zf->GetNames(); return Undefined(); }
int main(int argc, char *argv[]) { const char *archive; const char *file; const char *name; struct zip *za; struct zip_source *zs; char buf[100]; int err; prg = argv[0]; if (argc != 3) { fprintf(stderr, "usage: %s archive file\n", prg); return 1; } archive = argv[1]; file = argv[2]; if ((za=zip_open(archive, ZIP_CREATE, &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 ((zs=zip_source_file(za, file, 0, -1)) == NULL) { fprintf(stderr, "%s: error creating file source for `%s': %s\n", prg, file, zip_strerror(za)); return 1; } if ((name=strrchr(file, '/')) == NULL) name = file; if (zip_add(za, name, zs) == -1) { zip_source_free(zs); fprintf(stderr, "%s: can't add file `%s': %s\n", prg, file, zip_strerror(za)); return 1; } if (zip_close(za) == -1) { fprintf(stderr, "%s: can't close zip archive `%s'\n", prg, archive); return 1; } return 0; }
void SetFileData(const utf8 * path, void * data, size_t dataSize) override { zip_source_t * source = zip_source_buffer(_zip, data, dataSize, 0); sint64 index = zip_name_locate(_zip, path, 0); if (index == -1) { zip_add(_zip, path, source); } else { zip_replace(_zip, index, source); } }
int main() { int err = 0; int ret = 0; struct zip *z = NULL; struct zip_source *s = NULL; if ((z = zip_open("./first.zip", ZIP_CREATE | ZIP_EXCL, &err)) == NULL) { fprintf(stderr, "ERROR: zip_open(): [%s]\n", zip_strerror(z)); } s = zip_source_file(z, "zip.c", 0, -1); if(s != NULL) { if ((ret = zip_add(z, "zip.c", s)) < 0) { fprintf(stderr, "ERROR: zip_add(): [%s]\n", zip_strerror(z)); zip_source_free(s); } } else { fprintf(stderr, "ERROR: zip_source_file(): [%s]\n", zip_strerror(z)); zip_source_free(s); } s = zip_source_file(z, "unzip.c", 0, -1); if(s != NULL) { zip_add(z, "unzip.c", s); } else { fprintf(stderr, "ERROR: zip_source_file(): [%s]\n", zip_strerror(z)); zip_source_free(s); } char strerr[1024]; if ((err = zip_close(z)) < 0) { fprintf(stderr, "ERROR: zip_close(): [%s]\n", zip_strerror(z)); } return 0; }
static int add(int argc, char *argv[]) { zip_source_t *zs; if ((zs=zip_source_buffer(za, argv[1], strlen(argv[1]), 0)) == NULL) { fprintf(stderr, "can't create zip_source from buffer: %s\n", zip_strerror(za)); return -1; } if (zip_add(za, argv[0], zs) == -1) { zip_source_free(zs); fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za)); return -1; } return 0; }
static int add_nul(int argc, char *argv[]) { zip_source_t *zs; zip_uint64_t length = strtoull(argv[1], NULL, 10); if ((zs=source_nul(za, length)) == NULL) { fprintf(stderr, "can't create zip_source for length: %s\n", zip_strerror(za)); return -1; } if (zip_add(za, argv[0], zs) == -1) { zip_source_free(zs); fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za)); return -1; } return 0; }
int main(int argc, char *argv[]) { const char *archive; struct zip *za; struct zip_source *zs; char buf[100]; int err; prg = argv[0]; if (argc != 2) { fprintf(stderr, "usage: %s archive\n", prg); return 1; } archive = argv[1]; if ((za=zip_open(archive, ZIP_CREATE, &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 ((zs=zip_source_buffer(za, teststr, strlen(teststr), 0)) == NULL) { fprintf(stderr, "%s: can't create zip_source from buffer: %s\n", prg, zip_strerror(za)); exit(1); } if (zip_add(za, file, zs) == -1) { zip_source_free(zs); fprintf(stderr, "%s: can't add file '%s': %s\n", prg, file, zip_strerror(za)); return 1; } if (zip_close(za) == -1) { fprintf(stderr, "%s: can't close zip archive '%s': %s\n", prg, archive, zip_strerror(za)); return 1; } return 0; }
AbstractFSProvider::status_t ZIPProvider::ZIPHandle::writeFile(const FileName & file, const std::vector<uint8_t> & data, bool overwrite) { if (file.getFile().empty()) { return FAILURE; } bool replace = false; int index = zip_name_locate(handle, file.getPath().c_str(), 0); if (index != -1) { // File already exists. if (!overwrite) { return FAILURE; } else { replace = true; } } // Store data temporary because libzip writes data not until zip_close. tempStore.emplace_back(data); zip_source * source = zip_source_buffer(handle, tempStore.back().data(), static_cast<off_t>(tempStore.back().size()), 0); if (source == nullptr) { WARN(zip_strerror(handle)); zip_source_free(source); tempStore.pop_back(); return FAILURE; } int newIndex; if (replace) { newIndex = zip_replace(handle, index, source); } else { newIndex = zip_add(handle, file.getPath().c_str(), source); } if (newIndex == -1) { WARN(zip_strerror(handle)); zip_source_free(source); tempStore.pop_back(); return FAILURE; } dataWritten = true; return OK; }
void cnpy::npz_save_data(const std::string& zipname, const std::string& name, const unsigned char* data, const cnpy::Type dtype, const size_t elemSize, const std::vector<size_t>& shape, const char mode) { //first, append a .npy to the fname std::string fname(name); fname += ".npy"; if(mode=='w' && std::ifstream(zipname).is_open()) { // Remove the old file if present if(std::remove(zipname.c_str())!=0) throw std::runtime_error("Unable to overwrite "+zipname); } Handler<struct zip> zip = zip_open(zipname.c_str(), ZIP_CREATE, nullptr); if(zip.handle()==nullptr) throw std::runtime_error("Error opening npz file "+zipname); // Remove the old array if present int nameLookup = zip_name_locate(zip.handle(), fname.c_str(), 0); if(nameLookup>=0 && zip_delete(zip.handle(), nameLookup)!=0) throw std::runtime_error("Unable to overwrite "+name+" array"); std::vector<char> header = create_npy_header(dtype, elemSize, shape); const int dataSize = std::accumulate(shape.cbegin(), shape.cend(), elemSize, std::multiplies<size_t>()); ZipSourceCallbackData cbData(header, data, dataSize); Handler<struct zip_source> zipSource = zip_source_function(zip.handle(), zipSourceCallback, &cbData); if(zipSource.handle()==nullptr) throw std::runtime_error("Error creating "+name+" array"); zip_int64_t fid = zip_add(zip.handle(), fname.c_str(), zipSource.handle()); if(fid<0) { zip_source_free(zipSource.handle()); throw std::runtime_error("Error creating "+name+" array"); } zip.close(); }
static VALUE zipruby_archive_add_function(int argc, VALUE *argv, VALUE self) { VALUE name, mtime; struct zipruby_archive *p_archive; struct zip_source *zsource; struct read_proc *z; rb_scan_args(argc, argv, "11", &name, &mtime); rb_need_block(); Check_Type(name, T_STRING); if (NIL_P(mtime)) { mtime = rb_funcall(rb_cTime, rb_intern("now"), 0); } else if (!rb_obj_is_instance_of(mtime, rb_cTime)) { rb_raise(rb_eTypeError, "wrong argument type %s (expected Time)", rb_class2name(CLASS_OF(mtime))); } Data_Get_Struct(self, struct zipruby_archive, p_archive); Check_Archive(p_archive); if ((z = malloc(sizeof(struct read_proc))) == NULL) { zip_unchange_all(p_archive->archive); zip_unchange_archive(p_archive->archive); rb_raise(rb_eRuntimeError, "Add failed - %s: Cannot allocate memory", RSTRING_PTR(name)); } z->proc = rb_block_proc(); rb_ary_push(p_archive->sources, z->proc); z->mtime = TIME2LONG(mtime); if ((zsource = zip_source_proc(p_archive->archive, z)) == NULL) { free(z); rb_raise(Error, "Add failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive)); } if (zip_add(p_archive->archive, RSTRING_PTR(name), zsource) == -1) { zip_source_free(zsource); zip_unchange_all(p_archive->archive); zip_unchange_archive(p_archive->archive); rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive)); } return Qnil; }
void Zipper::_AddFile(uv_work_t *req) { closure_t *closure = static_cast<closure_t *>(req->data); struct zip_source *source = zip_source_file(closure->za, closure->path.c_str(), 0, 0); if (zip_add(closure->za, closure->name.c_str(), source) < 0) { std::stringstream s; s << "Cannot prepare file for add to zip: '" << closure->path << "'\n"; closure->error = true; closure->error_name = s.str(); zip_source_free(source); } if (zip_close(closure->za) < 0) { std::stringstream s; s << "Cannot add file to zip: '" << closure->path << "' (" << zip_strerror(closure->za) << ")\n"; closure->error = true; closure->error_name = s.str(); } }
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 int S_archive_add(lua_State* L) { struct zip** ar = check_archive(L, 1); const char* path = luaL_checkstring(L, 2); struct zip_source* src = S_create_source(L, *ar); int idx; if ( ! *ar ) return 0; idx = zip_add(*ar, path, src) + 1; if ( 0 == idx ) { zip_source_free(src); lua_pushstring(L, zip_strerror(*ar)); lua_error(L); } S_archive_add_ref(L, 0, 1, 4); lua_pushinteger(L, idx); return 1; }
void ZipFileOutput::dumpFile() { if(m_currentFile) { m_bufferedFiles.push_back(m_currentFile->str()); std::string & fileContent = m_bufferedFiles.back(); zip_source* source = zip_source_buffer(m_archiveHandle, fileContent.c_str(), fileContent.size(), 0); if(! source) throw FileAccessFailed(m_currentFilename, m_archive, "Failed to allocate ZLib source."); // check if the file exists struct zip_stat stat; if(zip_stat(m_archiveHandle, m_currentFilename.c_str(), 0, &stat) < 0) { // the file does not exist // add it to the archive if(zip_add(m_archiveHandle, m_currentFilename.c_str(), source) < 0) { zip_source_free(source); throw FileAccessFailed(m_currentFilename, m_archive, "Failed to add file to zip archive."); } } else { // the file exists // replace it in the archive if(zip_replace(m_archiveHandle, stat.index, source) < 0) { zip_source_free(source); throw FileAccessFailed(m_currentFilename, m_archive, "Failed to replace file in zip archive."); } } delete m_currentFile; m_currentFile = 0; } }
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; }
static int zip_create(const struct sr_output *o) { struct out_context *outc; struct sr_channel *ch; FILE *meta; struct zip *zipfile; struct zip_source *versrc, *metasrc; GVariant *gvar; GSList *l; int tmpfile, ret; char version[1], metafile[32], *s; outc = o->priv; if (outc->samplerate == 0) { if (sr_config_get(o->sdi->driver, o->sdi, NULL, NULL, SR_CONF_SAMPLERATE, &gvar) == SR_OK) { outc->samplerate = g_variant_get_uint64(gvar); g_variant_unref(gvar); } } /* Quietly delete it first, libzip wants replace ops otherwise. */ unlink(outc->filename); if (!(zipfile = zip_open(outc->filename, ZIP_CREATE, &ret))) return SR_ERR; /* "version" */ version[0] = '2'; if (!(versrc = zip_source_buffer(zipfile, version, 1, 0))) return SR_ERR; if (zip_add(zipfile, "version", versrc) == -1) { sr_info("Error saving version into zipfile: %s.", zip_strerror(zipfile)); return SR_ERR; } /* init "metadata" */ strcpy(metafile, "sigrok-meta-XXXXXX"); if ((tmpfile = g_mkstemp(metafile)) == -1) return SR_ERR; close(tmpfile); meta = g_fopen(metafile, "wb"); fprintf(meta, "[global]\n"); fprintf(meta, "sigrok version = %s\n", PACKAGE_VERSION); fprintf(meta, "[device 1]\ncapturefile = logic-1\n"); fprintf(meta, "total probes = %d\n", g_slist_length(o->sdi->channels)); s = sr_samplerate_string(outc->samplerate); fprintf(meta, "samplerate = %s\n", s); g_free(s); for (l = o->sdi->channels; l; l = l->next) { ch = l->data; if (ch->type != SR_CHANNEL_LOGIC) continue; if (!ch->enabled) continue; fprintf(meta, "probe%d = %s\n", ch->index + 1, ch->name); } fclose(meta); if (!(metasrc = zip_source_file(zipfile, metafile, 0, -1))) { unlink(metafile); return SR_ERR; } if (zip_add(zipfile, "metadata", metasrc) == -1) { unlink(metafile); return SR_ERR; } if ((ret = zip_close(zipfile)) == -1) { sr_info("Error saving zipfile: %s.", zip_strerror(zipfile)); unlink(metafile); return SR_ERR; } unlink(metafile); return SR_OK; }
static int zip_append(const struct sr_output *o, unsigned char *buf, int unitsize, int length) { struct out_context *outc; struct zip *archive; struct zip_source *logicsrc; zip_int64_t num_files; struct zip_file *zf; struct zip_stat zs; struct zip_source *metasrc; GKeyFile *kf; GError *error; gsize len; int chunk_num, next_chunk_num, tmpfile, ret, i; const char *entry_name; char *metafile, tmpname[32], chunkname[16]; outc = o->priv; if (!(archive = zip_open(outc->filename, 0, &ret))) return SR_ERR; if (zip_stat(archive, "metadata", 0, &zs) == -1) return SR_ERR; metafile = g_malloc(zs.size); zf = zip_fopen_index(archive, zs.index, 0); zip_fread(zf, metafile, zs.size); zip_fclose(zf); /* * If the file was only initialized but doesn't yet have any * data it in, it won't have a unitsize field in metadata yet. */ error = NULL; kf = g_key_file_new(); if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, &error)) { sr_err("Failed to parse metadata: %s.", error->message); return SR_ERR; } g_free(metafile); tmpname[0] = '\0'; if (!g_key_file_has_key(kf, "device 1", "unitsize", &error)) { if (error && error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) { sr_err("Failed to check unitsize key: %s", error ? error->message : "?"); return SR_ERR; } /* Add unitsize field. */ g_key_file_set_integer(kf, "device 1", "unitsize", unitsize); metafile = g_key_file_to_data(kf, &len, &error); strcpy(tmpname, "sigrok-meta-XXXXXX"); if ((tmpfile = g_mkstemp(tmpname)) == -1) return SR_ERR; if (write(tmpfile, metafile, len) < 0) { sr_dbg("Failed to create new metadata: %s", strerror(errno)); g_free(metafile); unlink(tmpname); return SR_ERR; } close(tmpfile); if (!(metasrc = zip_source_file(archive, tmpname, 0, -1))) { sr_err("Failed to create zip source for metadata."); g_free(metafile); unlink(tmpname); return SR_ERR; } if (zip_replace(archive, zs.index, metasrc) == -1) { sr_err("Failed to replace metadata file."); g_free(metafile); unlink(tmpname); return SR_ERR; } g_free(metafile); } g_key_file_free(kf); next_chunk_num = 1; num_files = zip_get_num_entries(archive, 0); for (i = 0; i < num_files; i++) { entry_name = zip_get_name(archive, i, 0); if (strncmp(entry_name, "logic-1", 7)) continue; if (strlen(entry_name) == 7) { /* This file has no extra chunks, just a single "logic-1". * Rename it to "logic-1-1" * and continue with chunk 2. */ if (zip_rename(archive, i, "logic-1-1") == -1) { sr_err("Failed to rename 'logic-1' to 'logic-1-1'."); unlink(tmpname); return SR_ERR; } next_chunk_num = 2; break; } else if (strlen(entry_name) > 8 && entry_name[7] == '-') { chunk_num = strtoull(entry_name + 8, NULL, 10); if (chunk_num >= next_chunk_num) next_chunk_num = chunk_num + 1; } } snprintf(chunkname, 15, "logic-1-%d", next_chunk_num); if (!(logicsrc = zip_source_buffer(archive, buf, length, FALSE))) { unlink(tmpname); return SR_ERR; } if (zip_add(archive, chunkname, logicsrc) == -1) { unlink(tmpname); return SR_ERR; } if ((ret = zip_close(archive)) == -1) { sr_info("error saving session file: %s", zip_strerror(archive)); unlink(tmpname); return SR_ERR; } unlink(tmpname); return SR_OK; }