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;
}
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;
}
std::string GetZipError(int err)
{
zip_error_t error;
zip_error_init_with_code(&error, err);
std::string errS(zip_error_strerror(&error));
zip_error_fini(&error);
return errS;
}
PCK_Catalog *PCK_OpenZipFile(const char *zipName){
int err=0;
zip_error_t error;
zip_error_init(&error);
struct zip* z = zip_open(zipName,ZIP_RDONLY,&err);
if(err != ZIP_ER_OK ){
zip_error_init_with_code(&error, err);
SDL_SetError("PCK_OpenZipFile failed:%d %s ",err, zip_error_strerror(&error));
zip_error_fini(&error);
return NULL;
}
PCK_Catalog* ptr=PCK_AllocCatalog();
ptr->openRW = zip_OpenRW;
ptr->close = zip_Close;
ptr->context = (SDL_RWops*)z;
}
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;
}
struct input_file *read_file_list (int argc, char **argv,
int *nf_r, char *errstr) {
struct input_file *list = (struct input_file *) NULL;
FILE *fp = (FILE *) NULL;
char line[16384], *av, *p, *s;
int a, f, nf = 0;
#ifndef _WIN32
glob_t gbuf;
int rv, op;
/* Init */
gbuf.gl_pathv = (char **) NULL;
#endif
int is_zip;
#ifdef ZIPSUPPORT
zip_t *z = (zip_t *) NULL;
zip_error_t ze;
struct zip_stat sb;
int zerrno;
int ent, nent;
const char *name;
int namelen;
zip_uint8_t opsys;
zip_uint32_t extattr;
#endif
/* Loop over arguments */
for(a = 0; a < argc; a++) {
av = argv[a];
if(*av == '@') { /* @list form */
av++; /* skip past the @ */
is_zip = is_zip_file(av, errstr);
if(is_zip < 0)
goto error;
if(is_zip) {
#ifdef ZIPSUPPORT
z = zip_open(av, 0, &zerrno);
if(!z) {
zip_error_init_with_code(&ze, zerrno);
report_err(errstr, "zip_open: %s: %s",
av, zip_error_strerror(&ze));
zip_error_fini(&ze);
goto error;
}
nent = zip_get_num_entries(z, 0);
if(nent < 0) {
report_err(errstr, "zip_get_num_entries: %s",
zip_strerror(z));
goto error;
}
for(ent = 0; ent < nent; ent++) {
if(zip_stat_index(z, ent, 0, &sb)) {
report_err(errstr, "zip_stat_index(%d): %s\n",
ent, zip_strerror(z));
goto error;
}
if(zip_file_get_external_attributes(z, ent, 0, &opsys, &extattr)) {
report_err(errstr, "zip_get_external_attributes(%d): %s\n",
ent, zip_strerror(z));
goto error;
}
name = sb.name;
namelen = strlen(name);
if((opsys != ZIP_OPSYS_AMIGA && extattr & 0x10) ||
(namelen > 0 && name[namelen-1] == '/'))
/* Is directory */
continue;
/* Otherwise, add to list */
list = (struct input_file *) realloc(list, (nf+1) * sizeof(struct input_file));
if(!list) {
report_syserr(errstr, "realloc");
goto error;
}
s = strdup(name);
if(!s) {
report_syserr(errstr, "strdup");
goto error;
}
list[nf].filename = s;
list[nf].ient = ent;
list[nf].iarg = a;
list[nf].arg = av;
nf++;
}
if(zip_close(z)) {
report_err(errstr, "zip_close: %s",
zip_strerror(z));
goto error;
}
z = (zip_t *) NULL;
#else
report_err(errstr, "not compiled with zip support");
goto error;
#endif
}
else {
fp = fopen(av, "r");
if(!fp) {
report_syserr(errstr, "open: %s", av);
goto error;
}
while(fgets(line, sizeof(line), fp)) {
p = sstrip(line);
if(*p) {
list = (struct input_file *) realloc(list, (nf+1) * sizeof(struct input_file));
if(!list) {
report_syserr(errstr, "realloc");
goto error;
}
s = strdup(p);
if(!s) {
report_syserr(errstr, "strdup");
goto error;
}
list[nf].filename = s;
list[nf].ient = -1;
list[nf].iarg = a;
list[nf].arg = av;
nf++;
}
}
if(ferror(fp)) {
report_syserr(errstr, "read: %s", av);
goto error;
}
fclose(fp);
fp = (FILE *) NULL;
}
}
else { /* glob or single filename */
#ifndef _WIN32
rv = glob(av, 0, NULL, &gbuf);
if(rv == 0) { /* succeeded */
/* Allocate block */
list = (struct input_file *) realloc(list,
(nf+gbuf.gl_pathc) * sizeof(struct input_file));
if(!list) {
report_syserr(errstr, "realloc");
goto error;
}
/* Zero out the new pointers */
memset(list+nf, 0, gbuf.gl_pathc * sizeof(struct input_file));
/* Record so we know to free them */
op = nf;
nf += gbuf.gl_pathc;
for(f = 0; f < gbuf.gl_pathc; f++) {
s = strdup(gbuf.gl_pathv[f]);
if(!s) {
report_syserr(errstr, "strdup");
goto error;
}
list[op].filename = s;
list[op].ient = -1;
list[op].iarg = a;
list[op].arg = av;
op++;
}
globfree(&gbuf);
gbuf.gl_pathv = (char **) NULL;
}
else if(rv == GLOB_NOMATCH) { /* no match */
#endif /* _WIN32 */
/* Assume it's a single entry. */
list = (struct input_file *) realloc(list, (nf+1) * sizeof(struct input_file));
if(!list) {
report_syserr(errstr, "realloc");
goto error;
}
s = strdup(av);
if(!s) {
report_syserr(errstr, "strdup");
goto error;
}
list[nf].filename = s;
list[nf].ient = -1;
list[nf].iarg = a;
list[nf].arg = av;
nf++;
#ifndef _WIN32
}
else {
report_err(errstr, "glob error: %s", av);
goto error;
}
#endif
}
}
*nf_r = nf;
return(list);
error:
if(fp)
fclose(fp);
#ifndef _WIN32
if(gbuf.gl_pathv)
globfree(&gbuf);
#endif
#ifdef ZIPSUPPORT
if(z) {
zip_close(z);
z = (zip_t *) NULL;
}
#endif
if(list) {
for(f = 0; f < nf; f++)
if(list[f].filename)
free((void *) list[f].filename);
free((void *) list);
}
return((struct input_file *) NULL);
}
