int ZipFile::EIO_AfterRead(eio_req *req)
{
read_closure_t *closure = static_cast<read_closure_t *>(req->data);
Handle<Value> argv[2];
if (closure->read < 0) {
std::stringstream s;
s << "Error while reading zip file: " << zip_file_strerror(closure->zf->file) << "\n";
argv[0] = Exception::Error(String::New(s.str().c_str()));
argv[1] = Undefined();
} else {
argv[0] = Undefined();
argv[1] = Integer::New(closure->read);
}
closure->cb->Call(Context::GetCurrent()->Global(), 2, argv);
closure->zf->Unref();
closure->cb.Dispose();
delete closure;
ev_unref(EV_DEFAULT_UC);
return 0;
}
/* {{{ php_zip_ops_read */
static size_t php_zip_ops_read(php_stream *stream, char *buf, size_t count)
{
ssize_t n = 0;
STREAM_DATA_FROM_STREAM();
if (self->za && self->zf) {
n = zip_fread(self->zf, buf, count);
if (n < 0) {
#if LIBZIP_VERSION_MAJOR < 1
int ze, se;
zip_file_error_get(self->zf, &ze, &se);
stream->eof = 1;
php_error_docref(NULL, E_WARNING, "Zip stream error: %s", zip_file_strerror(self->zf));
#else
zip_error_t *err;
err = zip_file_get_error(self->zf);
stream->eof = 1;
php_error_docref(NULL, E_WARNING, "Zip stream error: %s", zip_error_strerror(err));
zip_error_fini(err);
#endif
return 0;
}
/* cast count to signed value to avoid possibly negative n
* being cast to unsigned value */
if (n == 0 || n < (ssize_t)count) {
stream->eof = 1;
} else {
self->cursor += n;
}
}
return (n < 1 ? 0 : (size_t)n);
}
/** @private */
SR_PRIV int sr_sessionfile_check(const char *filename)
{
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
uint64_t version;
int ret;
char s[11];
if (!filename)
return SR_ERR_ARG;
if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) {
sr_err("Not a regular file: %s.", filename);
return SR_ERR;
}
if (!(archive = zip_open(filename, 0, NULL)))
/* No logging: this can be used just to check if it's
* a sigrok session file or not. */
return SR_ERR;
/* check "version" */
if (!(zf = zip_fopen(archive, "version", 0))) {
sr_dbg("Not a sigrok session file: no version found.");
zip_discard(archive);
return SR_ERR;
}
ret = zip_fread(zf, s, sizeof(s) - 1);
if (ret < 0) {
sr_err("Failed to read version file: %s",
zip_file_strerror(zf));
zip_fclose(zf);
zip_discard(archive);
return SR_ERR;
}
zip_fclose(zf);
s[ret] = '\0';
version = g_ascii_strtoull(s, NULL, 10);
if (version == 0 || version > 2) {
sr_dbg("Cannot handle sigrok session file version %" PRIu64 ".",
version);
zip_discard(archive);
return SR_ERR;
}
sr_spew("Detected sigrok session file version %" PRIu64 ".", version);
/* read "metadata" */
if (zip_stat(archive, "metadata", 0, &zs) < 0) {
sr_dbg("Not a valid sigrok session file.");
zip_discard(archive);
return SR_ERR;
}
zip_discard(archive);
return SR_OK;
}
/**
* Read the contents of the first file of the ZIP file and load
* it into a ModPlugFile.
**/
static ModPlugFile* loadZipFile(const char *path)
{
ModPlugFile *self_ = NULL;
int err = 0;
struct zip *zf = zip_open(path, 0, &err);
if (!zf) return NULL;
struct zip_stat sb;
// FIXME: Assumes the first file is the mod-file
if (zip_stat_index(zf, 0, 0, &sb)) {
MPSP_EPRINTF("failed to stat ZIP member: %s\n", zip_strerror(zf));
goto exit1;
}
// FIXME: Assumes the first file is the mod-file
struct zip_file *file = zip_fopen_index(zf, 0, 0);
if (!file) {
MPSP_EPRINTF("failed to open ZIP member: %s\n", zip_strerror(zf));
goto exit1;
}
void *data = malloc(sb.size);
if (!data) {
MPSP_EPRINTF("failed to allocate memory: %s\n", strerror(errno));
goto exit2;
}
if (zip_fread(file, data, sb.size) != sb.size) {
MPSP_EPRINTF("failed to read ZIP member: %s\n", zip_file_strerror(file));
goto exit3;
}
self_ = ModPlug_Load(data, sb.size);
exit3:
free(data);
exit2:
(void) zip_fclose(file);
exit1:
(void) zip_close(zf);
return self_;
}
void ZipFile::Work_ReadFile(uv_work_t* req) {
closure_t *closure = static_cast<closure_t *>(req->data);
struct zip_file *zf_ptr = NULL;
int idx = -1;
std::vector<std::string>::iterator it = std::find(closure->zf->names_.begin(),
closure->zf->names_.end(),
closure->name);
if (it != closure->zf->names_.end()) {
idx = distance(closure->zf->names_.begin(), it);
}
if (idx == -1) {
std::stringstream s;
s << "No file found by the name of: '" << closure->name << "\n";
closure->error = true;
closure->error_name = s.str();
} else {
if ((zf_ptr = zip_fopen_index(closure->za, idx, 0)) == NULL) {
std::stringstream s;
s << "cannot open file #" << idx << " in "
<< closure->name << ": archive error: " << zip_strerror(closure->za) << "\n";
closure->error = true;
closure->error_name = s.str();
} else {
struct zip_stat st;
zip_stat_index(closure->za, idx, 0, &st);
closure->data.clear();
closure->data.resize(st.size);
int result = 0;
result = static_cast<int>(zip_fread(zf_ptr, reinterpret_cast<void*> (&closure->data[0]), closure->data.size()));
if (result < 0) {
std::stringstream s;
s << "error reading file #" << idx << " in "
<< closure->name << ": archive error: " << zip_file_strerror(zf_ptr) << "\n";
closure->error = true;
closure->error_name = s.str();
}
}
}
zip_fclose(zf_ptr);
}
Handle<Value> ZipFile::Close(const Arguments& args)
{
ZipFile* zf = ObjectWrap::Unwrap<ZipFile>(args.This());
if (zf->file == NULL)
return ThrowException(Exception::Error(String::New("No file opened!")));
if (zip_fclose(zf->file) != 0) {
std::stringstream s;
s << "Error while closing zip file: " << zip_file_strerror(zf->file) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
zf->file = NULL;
return Undefined();
}
/**
* Read metadata entries from a session archive.
*
* @param[in] archive An open ZIP archive.
* @param[in] entry Stat buffer filled in for the metadata archive member.
*
* @return A new key/value store containing the session metadata.
*
* @private
*/
SR_PRIV GKeyFile *sr_sessionfile_read_metadata(struct zip *archive,
const struct zip_stat *entry)
{
GKeyFile *keyfile;
GError *error;
struct zip_file *zf;
char *metabuf;
int metalen;
if (entry->size > G_MAXINT || !(metabuf = g_try_malloc(entry->size))) {
sr_err("Metadata buffer allocation failed.");
return NULL;
}
zf = zip_fopen_index(archive, entry->index, 0);
if (!zf) {
sr_err("Failed to open metadata: %s", zip_strerror(archive));
g_free(metabuf);
return NULL;
}
metalen = zip_fread(zf, metabuf, entry->size);
if (metalen < 0) {
sr_err("Failed to read metadata: %s", zip_file_strerror(zf));
zip_fclose(zf);
g_free(metabuf);
return NULL;
}
zip_fclose(zf);
keyfile = g_key_file_new();
error = NULL;
g_key_file_load_from_data(keyfile, metabuf, metalen,
G_KEY_FILE_NONE, &error);
g_free(metabuf);
if (error) {
sr_err("Failed to parse metadata: %s", error->message);
g_error_free(error);
g_key_file_free(keyfile);
return NULL;
}
return keyfile;
}
static int
cat(int argc, char *argv[]) {
/* output file contents to stdout */
zip_uint64_t idx;
zip_int64_t n;
zip_file_t *zf;
char buf[8192];
int err;
idx = strtoull(argv[0], NULL, 10);
#ifdef _WIN32
/* Need to set stdout to binary mode for Windows */
setmode(fileno(stdout), _O_BINARY);
#endif
if ((zf=zip_fopen_index(za, idx, 0)) == NULL) {
fprintf(stderr, "can't open file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
return -1;
}
while ((n=zip_fread(zf, buf, sizeof(buf))) > 0) {
if (fwrite(buf, (size_t)n, 1, stdout) != 1) {
zip_fclose(zf);
fprintf(stderr, "can't write file contents to stdout: %s\n", strerror(errno));
return -1;
}
}
if (n == -1) {
zip_fclose(zf);
fprintf(stderr, "can't read file at index '%" PRIu64 "': %s\n", idx, zip_file_strerror(zf));
return -1;
}
if ((err = zip_fclose(zf)) != 0) {
zip_error_t error;
zip_error_init_with_code(&error, err);
fprintf(stderr, "can't close file at index '%" PRIu64 "': %s\n", idx, zip_error_strerror(&error));
return -1;
}
return 0;
}
/* {{{ php_zip_ops_read */
static size_t php_zip_ops_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
{
int n = 0;
STREAM_DATA_FROM_STREAM();
if (self->za && self->zf) {
n = (size_t)zip_fread(self->zf, buf, (int)count);
if (n < 0) {
int ze, se;
zip_file_error_get(self->zf, &ze, &se);
stream->eof = 1;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zip stream error: %s", zip_file_strerror(self->zf));
return 0;
}
if (n == 0 || n < count) {
stream->eof = 1;
} else {
self->cursor += n;
}
}
return n<1 ? 0 : n;
}
static int S_archive_file_read(lua_State* L) {
struct zip_file** file = check_archive_file(L, 1);
int len = luaL_checkint(L, 2);
char* buff;
if ( len <= 0 ) luaL_argerror(L, 2, "Must be > 0");
if ( ! *file ) return 0;
buff = (char*)lua_newuserdata(L, len);
len = zip_fread(*file, buff, len);
if ( -1 == len ) {
lua_pushnil(L);
lua_pushstring(L, zip_file_strerror(*file));
return 2;
}
lua_pushlstring(L, buff, len);
return 1;
}
/* {{{ php_zip_ops_read */
static size_t php_zip_ops_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
{
ssize_t n = 0;
STREAM_DATA_FROM_STREAM();
if (self->za && self->zf) {
n = zip_fread(self->zf, buf, count);
if (n < 0) {
int ze, se;
zip_file_error_get(self->zf, &ze, &se);
stream->eof = 1;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zip stream error: %s", zip_file_strerror(self->zf));
return 0;
}
/* cast count to signed value to avoid possibly negative n
* being cast to unsigned value */
if (n == 0 || n < (ssize_t)count) {
stream->eof = 1;
} else {
self->cursor += n;
}
}
return (n < 1 ? 0 : (size_t)n);
}
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;
}
QByteArray readZipFile(const char *archiveName, const char *fileName)
{
int error = 0;
zip *archive;
zip_file *file;
char buffer[1024];
int readsize = 0;
QByteArray ret;
archive = zip_open(archiveName, 0, &error);
if (!archive)
{
qDebug() << "Error when opening archive" << archiveName;
return ret;
}
file = zip_fopen(archive, fileName, 0);
if (!file)
{
qDebug() << "Error when opening file "<< fileName <<" in archive: " << archiveName <<" : " << zip_strerror(archive);
zip_close(archive);
return ret;
}
do
{
ret.append(buffer, readsize);
readsize = zip_fread(file, buffer, 1024);
} while (readsize > 0) ;
if (readsize < 0)
{
qDebug() << "Error when reading file "<< fileName <<" in archive: " << archiveName <<" : " << zip_file_strerror(file);
}
zip_fclose(file);
zip_close(archive);
return ret;
}
Handle<Value> ZipFile::readFileSync(const Arguments& args) {
HandleScope scope;
if (args.Length() != 1 || !args[0]->IsString())
return ThrowException(Exception::TypeError(
String::New("first argument must be a file name inside the zip")));
std::string name = TOSTR(args[0]);
ZipFile* zf = ObjectWrap::Unwrap<ZipFile>(args.This());
struct zip_file *zf_ptr;
int idx = -1;
std::vector<std::string>::iterator it = std::find(zf->names_.begin(), zf->names_.end(), name);
if (it != zf->names_.end()) {
idx = distance(zf->names_.begin(), it);
}
if (idx == -1) {
std::stringstream s;
s << "No file found by the name of: '" << name << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
if ((zf_ptr=zip_fopen_index(zf->archive_, idx, 0)) == NULL) {
zip_fclose(zf_ptr);
std::stringstream s;
s << "cannot open file #" << idx << " in " << name << ": archive error: " << zip_strerror(zf->archive_) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
struct zip_stat st;
zip_stat_index(zf->archive_, idx, 0, &st);
std::vector<unsigned char> data;
data.clear();
data.resize(st.size);
int result = 0;
result = static_cast<int>(zip_fread(zf_ptr, reinterpret_cast<void*> (&data[0]), data.size()));
if (result < 0) {
zip_fclose(zf_ptr);
std::stringstream s;
s << "error reading file #" << idx << " in " << name << ": archive error: " << zip_file_strerror(zf_ptr) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
node::Buffer *retbuf = Buffer::New(reinterpret_cast<char *>(&data[0]), data.size());
zip_fclose(zf_ptr);
return scope.Close(retbuf->handle_);
}