CacheLoader *cache_loader_new(FileData *fd, CacheDataType load_mask,
CacheLoaderDoneFunc done_func, gpointer done_data)
{
CacheLoader *cl;
gchar *found;
if (!fd || !isfile(fd->path)) return NULL;
cl = g_new0(CacheLoader, 1);
cl->fd = file_data_ref(fd);
cl->done_func = done_func;
cl->done_data = done_data;
found = cache_find_location(CACHE_TYPE_SIM, cl->fd->path);
if (found && filetime(found) == filetime(cl->fd->path))
{
cl->cd = cache_sim_data_load(found);
}
g_free(found);
if (!cl->cd) cl->cd = cache_sim_data_new();
cl->todo_mask = load_mask;
cl->done_mask = CACHE_LOADER_NONE;
cl->il = NULL;
cl->idle_id = g_idle_add(cache_loader_idle_cb, cl);
cl->error = FALSE;
return cl;
}
void addFileToZip(zipFile z, String filePath, String pathInZip, bool silent) {
if(!silent)
printf("Packaging %s as %s\n", filePath.c_str(), pathInZip.c_str());
zip_fileinfo zi;
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
zi.dosDate = 0;
zi.internal_fa = 0;
zi.external_fa = 0;
filetime(filePath.c_str(),&zi.tmz_date,&zi.dosDate);
zipOpenNewFileInZip(z, pathInZip.c_str(), &zi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, 2);
FILE *f = fopen(filePath.c_str(), "rb");
fseek(f, 0, SEEK_END);
long fileSize = ftell(f);
fseek(f, 0, SEEK_SET);
char *buf = (char*) malloc(fileSize);
fread(buf, fileSize, 1, f);
zipWriteInFileInZip(z, buf, fileSize);
free(buf);
fclose(f);
zipCloseFileInZip(z);
}
static void layout_real_time_update(LayoutWindow *lw)
{
/* this resets the last time stamp of path so that a refresh does not occur
* from an internal file operation.
*/
if (lw->path) lw->last_time = filetime(lw->path);
}
static void layout_refresh_by_time(LayoutWindow *lw)
{
layout_refresh_lists(lw);
if (lw->image && filetime(layout_image_get_path(lw)) >= lw->last_time)
{
layout_image_refresh(lw);
}
}
static void layout_refresh_lists(LayoutWindow *lw)
{
if (lw->path) lw->last_time = filetime(lw->path);
if (lw->vdl) vdlist_refresh(lw->vdl);
if (lw->vdt) vdtree_refresh(lw->vdt);
if (lw->vfl) vflist_refresh(lw->vfl);
if (lw->vfi) vficon_refresh(lw->vfi);
}
static void layout_sync_path(LayoutWindow *lw)
{
if (!lw->path) return;
lw->last_time = filetime(lw->path);
gtk_entry_set_text(GTK_ENTRY(lw->path_entry), lw->path);
if (lw->vdl) vdlist_set_path(lw->vdl, lw->path);
if (lw->vdt) vdtree_set_path(lw->vdt, lw->path);
if (lw->vfl) vflist_set_path(lw->vfl, lw->path);
if (lw->vfi) vficon_set_path(lw->vfi, lw->path);
}
static gint
thumb_loader_mark_failure (ThumbLoader * tl)
{
gchar *cache_dir;
gint success = FALSE;
mode_t mode = 0755;
if (!tl)
return FALSE;
cache_dir =
cache_get_location (CACHE_THUMBS, tl->path, FALSE, NULL, &mode);
if (cache_ensure_dir_exists (cache_dir, mode))
{
gchar *cache_path;
FILE *f;
cache_path =
g_strconcat (cache_dir, "/", filename_from_path (tl->path),
PORNVIEW_CACHE_THUMB_EXT, NULL);
f = fopen (cache_path, "w");
if (f)
{
struct utimbuf ut;
fclose (f);
ut.actime = ut.modtime = filetime (tl->path);
if (ut.modtime > 0)
{
utime (cache_path, &ut);
}
success = TRUE;
}
g_free (cache_path);
}
g_free (cache_dir);
return success;
}
static gint
thumb_loader_save_to_cache (ThumbLoader * tl)
{
gchar *cache_dir;
gint success = FALSE;
mode_t mode = 0755;
if (!tl || !tl->pixbuf)
return FALSE;
cache_dir =
cache_get_location (CACHE_THUMBS, tl->path, FALSE, NULL, &mode);
if (cache_ensure_dir_exists (cache_dir, mode))
{
gchar *cache_path;
cache_path =
g_strconcat (cache_dir, "/", filename_from_path (tl->path),
PORNVIEW_CACHE_THUMB_EXT, NULL);
success = pixbuf_to_file_as_png (tl->pixbuf, cache_path);
if (success)
{
struct utimbuf ut;
/*
* set thumb time to that of source file
*/
ut.actime = ut.modtime = filetime (tl->path);
if (ut.modtime > 0)
{
utime (cache_path, &ut);
}
}
g_free (cache_path);
}
g_free (cache_dir);
return success;
}
static gint layout_check_for_update_cb(gpointer data)
{
LayoutWindow *lw = data;
if (!update_on_time_change) return TRUE;
if (lw->path)
{
time_t new_time;
new_time = filetime(lw->path);
if (new_time > 0 && new_time > lw->last_time)
{
if (debug) printf("layout path time changed, refreshing...\n");
layout_refresh_by_time(lw);
}
}
return TRUE;
}
zipFile zipopen (const char* path, const char* filenameinzip, int append)
{
zipFile zf = NULL;
int err=ZIP_OK;
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc);
zf = zipOpen2(path,append,NULL,&ffunc);
#else
zf = zipOpen(path, append);
#endif
if (zf == NULL) return NULL;
zip_fileinfo zi;
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
zi.dosDate = 0;
zi.internal_fa = 0;
zi.external_fa = 0;
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
NULL,0,NULL,0,NULL,
Z_DEFLATED,
Z_DEFAULT_COMPRESSION);
if (err != ZIP_OK)
{
zipClose(zf, NULL);
return NULL;
}
return zf;
}
static void info_tab_general_sync(InfoData *id, gpointer data)
{
InfoTabGeneral *tab = data;
gchar *buf;
gtk_label_set_text(GTK_LABEL(tab->label_file_time), text_from_time(filetime(id->path)));
tab->byte_size = filesize(id->path);
buf = text_from_size(tab->byte_size);
gtk_label_set_text(GTK_LABEL(tab->label_file_size), buf);
g_free(buf);
gtk_label_set_text(GTK_LABEL(tab->label_dimensions), "");
gtk_label_set_text(GTK_LABEL(tab->label_transparent), "");
gtk_label_set_text(GTK_LABEL(tab->label_image_size), "");
gtk_label_set_text(GTK_LABEL(tab->label_compression), "");
gtk_label_set_text(GTK_LABEL(tab->label_mime_type), "");
info_tab_general_sync_perm(tab, id);
tab->compression_done = FALSE;
}
gint
thumb_loader_start (ThumbLoader * tl,
void (*func_done) (ThumbLoader *, gpointer),
gpointer data_done)
{
gchar *cache_path = NULL;
if (!tl || !tl->path)
return FALSE;
tl->func_done = func_done;
tl->data_done = data_done;
if (conf.enable_thumb_caching)
{
cache_path =
cache_find_location (CACHE_THUMBS, tl->path,
PORNVIEW_CACHE_THUMB_EXT);
if (cache_path)
{
if (filetime (cache_path) == filetime (tl->path))
{
if (filesize (cache_path) == 0)
{
g_free (cache_path);
return FALSE;
}
}
else
{
g_free (cache_path);
cache_path = NULL;
}
}
}
if (cache_path)
{
thumb_loader_setup (tl, cache_path);
g_free (cache_path);
tl->from_cache = TRUE;
}
else
{
thumb_loader_setup (tl, tl->path);
}
if (!image_loader_start (tl->il, cb_thumb_loader_done, tl))
{
/*
* try from original if cache attempt
*/
if (tl->from_cache)
{
tl->from_cache = FALSE;
image_loader_free (tl->il);
thumb_loader_setup (tl, tl->path);
if (image_loader_start (tl->il, cb_thumb_loader_done, tl))
return TRUE;
}
/*
* mark failed thumbnail in cache with 0 byte file
*/
if (conf.enable_thumb_caching)
{
thumb_loader_mark_failure (tl);
}
image_loader_free (tl->il);
tl->il = NULL;
return FALSE;
}
return TRUE;
}
int main(int argc, char *argv[])
{
zipFile zf = NULL;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc = {0};
#endif
char *zipfilename = NULL;
const char* password = NULL;
void* buf = NULL;
int size_buf = WRITEBUFFERSIZE;
int zipfilenamearg = 0;
int errclose = 0;
int err = 0;
int i = 0;
int opt_overwrite = APPEND_STATUS_CREATE;
int opt_compress_level = Z_DEFAULT_COMPRESSION;
int opt_exclude_path = 0;
do_banner();
if (argc == 1)
{
do_help();
return 0;
}
/* Parse command line options */
for (i = 1; i < argc; i++)
{
if ((*argv[i]) == '-')
{
const char *p = argv[i]+1;
while ((*p) != '\0')
{
char c = *(p++);;
if ((c == 'o') || (c == 'O'))
opt_overwrite = APPEND_STATUS_CREATEAFTER;
if ((c == 'a') || (c == 'A'))
opt_overwrite = APPEND_STATUS_ADDINZIP;
if ((c >= '0') && (c <= '9'))
opt_compress_level = (c - '0');
if ((c == 'j') || (c == 'J'))
opt_exclude_path = 1;
if (((c == 'p') || (c == 'P')) && (i+1 < argc))
{
password=argv[i+1];
i++;
}
}
}
else
{
if (zipfilenamearg == 0)
zipfilenamearg = i;
}
}
if (zipfilenamearg == 0)
{
do_help();
return 0;
}
zipfilename = argv[zipfilenamearg];
buf = (void*)malloc(size_buf);
if (buf == NULL)
{
printf("Error allocating memory\n");
return ZIP_INTERNALERROR;
}
if (opt_overwrite == 2)
{
/* If the file don't exist, we not append file */
if (check_file_exists(zipfilename) == 0)
opt_overwrite = 1;
}
else if (opt_overwrite == 0)
{
/* If ask the user what to do because append and overwrite args not set */
//if (check_file_exists(zipfilename) != 0)
//{
// char rep = 0;
// do
// {
// char answer[128];
// printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ", zipfilename);
// if (scanf("%1s", answer) != 1)
// exit(EXIT_FAILURE);
// rep = answer[0];
// if ((rep >= 'a') && (rep <= 'z'))
// rep -= 0x20;
// }
// while ((rep != 'Y') && (rep != 'N') && (rep != 'A'));
// if (rep == 'A')
// opt_overwrite = 2;
// else if (rep == 'N')
// {
// do_help();
// free(buf);
// return 0;
// }
//}
}
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
zf = zipOpen2_64(zipfilename, opt_overwrite, NULL, &ffunc);
#else
zf = zipOpen64(zipfilename, opt_overwrite);
#endif
if (zf == NULL)
{
printf("error opening %s\n", zipfilename);
err = ZIP_ERRNO;
}
else
printf("creating %s\n", zipfilename);
/* Go through command line args looking for files to add to zip */
for (i = zipfilenamearg + 1; (i < argc) && (err == ZIP_OK); i++)
{
FILE *fin = NULL;
int size_read = 0;
const char* filenameinzip = argv[i];
const char *savefilenameinzip;
zip_fileinfo zi = {0};
unsigned long crcFile = 0;
int zip64 = 0;
/* Skip command line options */
if ((((*(argv[i])) == '-') || ((*(argv[i])) == '/')) && (strlen(argv[i]) == 2) &&
((argv[i][1] == 'o') || (argv[i][1] == 'O') || (argv[i][1] == 'a') || (argv[i][1] == 'A') ||
(argv[i][1] == 'p') || (argv[i][1] == 'P') || ((argv[i][1] >= '0') && (argv[i][1] <= '9'))))
continue;
/* Get information about the file on disk so we can store it in zip */
filetime(filenameinzip, &zi.tmz_date, &zi.dosDate);
if ((password != NULL) && (err == ZIP_OK))
err = get_file_crc(filenameinzip, buf, size_buf, &crcFile);
zip64 = is_large_file(filenameinzip);
/* Construct the filename that our file will be stored in the zip as.
The path name saved, should not include a leading slash.
If it did, windows/xp and dynazip couldn't read the zip file. */
savefilenameinzip = filenameinzip;
while (savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/')
savefilenameinzip++;
/* Should the file be stored with any path info at all? */
if (opt_exclude_path)
{
const char *tmpptr = NULL;
const char *lastslash = 0;
for (tmpptr = savefilenameinzip; *tmpptr; tmpptr++)
{
if (*tmpptr == '\\' || *tmpptr == '/')
lastslash = tmpptr;
}
if (lastslash != NULL)
savefilenameinzip = lastslash + 1; /* base filename follows last slash. */
}
/* Add to zip file */
err = zipOpenNewFileInZip3_64(zf, savefilenameinzip, &zi,
NULL, 0, NULL, 0, NULL /* comment*/,
(opt_compress_level != 0) ? Z_DEFLATED : 0,
opt_compress_level,0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
password, crcFile, zip64);
if (err != ZIP_OK)
printf("error in opening %s in zipfile (%d)\n", filenameinzip, err);
else
{
fin = FOPEN_FUNC(filenameinzip, "rb");
if (fin == NULL)
{
err = ZIP_ERRNO;
printf("error in opening %s for reading\n", filenameinzip);
}
}
if (err == ZIP_OK)
{
/* Read contents of file and write it to zip */
do
{
size_read = (int)fread(buf, 1, size_buf, fin);
if ((size_read < size_buf) && (feof(fin) == 0))
{
printf("error in reading %s\n",filenameinzip);
err = ZIP_ERRNO;
}
if (size_read > 0)
{
err = zipWriteInFileInZip(zf, buf, size_read);
if (err < 0)
printf("error in writing %s in the zipfile (%d)\n", filenameinzip, err);
}
}
while ((err == ZIP_OK) && (size_read > 0));
}
if (fin)
fclose(fin);
if (err < 0)
err = ZIP_ERRNO;
else
{
err = zipCloseFileInZip(zf);
if (err != ZIP_OK)
printf("error in closing %s in the zipfile (%d)\n", filenameinzip, err);
}
}
errclose = zipClose(zf, NULL);
if (errclose != ZIP_OK)
printf("error in closing %s (%d)\n", zipfilename, errclose);
free(buf);
return err;
}
int Zip::compressFiles(std::string sourcePath, std::vector<std::string> files, std::string output){
char buffer[Zip::WRITE_BUFFER_SIZE];
zipFile zf = zipOpen(output.c_str(), APPEND_STATUS_CREATE);
if (zf == 0){
return 3;
}
for (unsigned int i= 0; i < files.size(); i++) {
std::string fileToZip;
if (sourcePath.size() == 0){
fileToZip = files[i];
} else {
fileToZip = sourcePath.append("\\").append(files[i]);
}
zip_fileinfo fileInfo = {};
ZeroMemory( &fileInfo.tmz_date, sizeof( fileInfo.tmz_date ) );
filetime(fileToZip.c_str(), &fileInfo.tmz_date, &fileInfo.dosDate);
int error = zipOpenNewFileInZip2(zf, fileToZip.c_str(),
&fileInfo, 0, 0, 0, 0,
0,
Z_DEFLATED,
Z_DEFAULT_COMPRESSION, 0
);
if (error != ZIP_OK) {
zipClose(zf, 0);
return 4;
}
FILE *fin = fopen(fileToZip.c_str(), "rb");
if (fin == 0) {
zipClose(zf, NULL);
return 5;
}
int size_read;
do {
size_read = (int)fread(&buffer, 1, Zip::WRITE_BUFFER_SIZE, fin);
if (size_read < Zip::WRITE_BUFFER_SIZE)
if (feof(fin) == 0) {
zipClose(zf, 0);
fclose(fin);
return 6;
}
if (size_read > 0) {
error = zipWriteInFileInZip (zf, &buffer, size_read);
if (error < 0) {
zipClose(zf, 0);
fclose(fin);
return 7;
}
}
} while (size_read > 0);
if (fin){
fclose(fin);
}
error = zipCloseFileInZip(zf);
if (error != ZIP_OK) {
zipClose(zf, 0);
return 8;
}
}
int errclose = zipClose(zf, 0);
if (errclose != ZIP_OK) {
return 9;
}
return 10;
}
void cfgflex (char * befbuf)
//*************************************************************************
//
// cfgflex
//
//*************************************************************************
{
int a, i;
int promptz = 0; // Zaehler der Nodeprompts
char fn[20]; // Dateiname des Configfiles
char fo[20]; // Dateiname des Antwortfiles
char ziel[30]; // Nodecall
char line[255]; // Noderueckgabe
strcpy(fn, "cfgflex.bcm");
strcpy(fo, "cfgflex.out");
strncpy(ziel, befbuf, 29);
ziel[29] = 0;
trace(report, "cfgflex", "connect %s", ziel);
timeout(1);
lastcmd("Connect");
if (makeconnect(m.mycall[1], ziel))
{
setsession();
*b->logincall = 0;
if (filetime(fn))
{
trace(report, "cfgflex", "sending %s", fn);
FILE *f = s_fopen(fn, "lrt");
lastcmd("TX cfg_file");
while ((a = fgetc(f)) != EOF)
{
getclear_tnc();
timeout(1);
waitfor(e_ticsfull);
putv(a);
if (a == LF) promptz++; // zaehlt prompts vorwaerts
}
putv(LF);
putv(LF);
s_fclose(f);
trace(report, "cfgflex", "receive %s", fo); // speichert Rueckgaben
FILE *g = s_fopen(fo, "lwt");
lastcmd("RX cfg_result");
if (g) // JJ
{
while (promptz > 0)
{
getline(line, BUFLEN - 1, 1);
if (! strncmp(line, "=>", 2))
promptz--; // zaehlt prompts rueckwaerts
if (! strncmp(line, "***", 3))
promptz = 0; // link failure
fprintf(g, "%s", line);
fputc(LF, g);
}
}
s_fclose(g);
}
lastcmd("Delay");
for (i = 0; i < 100; i++)
{
wdelay(226);
getclear_tnc();
}
mblogout(0);
mbdisconnect(1); // wait for data to be sent
}
}
static gboolean cache_loader_process(CacheLoader *cl)
{
if (cl->todo_mask & CACHE_LOADER_SIMILARITY &&
!cl->cd->similarity)
{
GdkPixbuf *pixbuf;
if (!cl->il && !cl->error)
{
cl->il = image_loader_new(cl->fd);
g_signal_connect(G_OBJECT(cl->il), "error", (GCallback)cache_loader_error_cb, cl);
g_signal_connect(G_OBJECT(cl->il), "done", (GCallback)cache_loader_done_cb, cl);
if (image_loader_start(cl->il))
{
return FALSE;
}
cl->error = TRUE;
}
pixbuf = image_loader_get_pixbuf(cl->il);
if (pixbuf)
{
if (!cl->error)
{
ImageSimilarityData *sim;
sim = image_sim_new_from_pixbuf(pixbuf);
cache_sim_data_set_similarity(cl->cd, sim);
image_sim_free(sim);
cl->done_mask |= CACHE_LOADER_SIMILARITY;
}
/* we have the dimensions via pixbuf */
if (!cl->cd->dimensions)
{
cache_sim_data_set_dimensions(cl->cd, gdk_pixbuf_get_width(pixbuf),
gdk_pixbuf_get_height(pixbuf));
if (cl->todo_mask & CACHE_LOADER_DIMENSIONS)
{
cl->todo_mask &= ~CACHE_LOADER_DIMENSIONS;
cl->done_mask |= CACHE_LOADER_DIMENSIONS;
}
}
}
image_loader_free(cl->il);
cl->il = NULL;
cl->todo_mask &= ~CACHE_LOADER_SIMILARITY;
}
else if (cl->todo_mask & CACHE_LOADER_DIMENSIONS &&
!cl->cd->dimensions)
{
if (!cl->error &&
image_load_dimensions(cl->fd, &cl->cd->width, &cl->cd->height))
{
cl->cd->dimensions = TRUE;
cl->done_mask |= CACHE_LOADER_DIMENSIONS;
}
else
{
cl->error = TRUE;
}
cl->todo_mask &= ~CACHE_LOADER_DIMENSIONS;
}
else if (cl->todo_mask & CACHE_LOADER_MD5SUM &&
!cl->cd->have_md5sum)
{
if (md5_get_digest_from_file_utf8(cl->fd->path, cl->cd->md5sum))
{
cl->cd->have_md5sum = TRUE;
cl->done_mask |= CACHE_LOADER_MD5SUM;
}
else
{
cl->error = TRUE;
}
cl->todo_mask &= ~CACHE_LOADER_MD5SUM;
}
else if (cl->todo_mask & CACHE_LOADER_DATE &&
!cl->cd->have_date)
{
time_t date = -1;
gchar *text;
text = metadata_read_string(cl->fd, "formatted.DateTime", METADATA_FORMATTED);
if (text)
{
struct tm t;
memset(&t, 0, sizeof(t));
if (sscanf(text, "%d:%d:%d %d:%d:%d", &t.tm_year, &t.tm_mon, &t.tm_mday,
&t.tm_hour, &t.tm_min, &t.tm_sec) == 6)
{
t.tm_year -= 1900;
t.tm_mon -= 1;
t.tm_isdst = -1;
date = mktime(&t);
}
g_free(text);
}
cl->cd->date = date;
cl->cd->have_date = TRUE;
cl->done_mask |= CACHE_LOADER_DATE;
cl->todo_mask &= ~CACHE_LOADER_DATE;
}
else
{
/* done, save then call done function */
if (options->thumbnails.enable_caching &&
cl->done_mask != CACHE_LOADER_NONE)
{
gchar *base;
mode_t mode = 0755;
base = cache_get_location(CACHE_TYPE_SIM, cl->fd->path, FALSE, &mode);
if (recursive_mkdir_if_not_exists(base, mode))
{
g_free(cl->cd->path);
cl->cd->path = cache_get_location(CACHE_TYPE_SIM, cl->fd->path, TRUE, NULL);
if (cache_sim_data_save(cl->cd))
{
filetime_set(cl->cd->path, filetime(cl->fd->path));
}
}
g_free(base);
}
cl->idle_id = 0;
if (cl->done_func)
{
cl->done_func(cl, cl->error, cl->done_data);
}
return FALSE;
}
return TRUE;
}
long zipCompressFile( char **in,
long in_count,
char *out)
{
long status = 0;
long i = 0;
long size_read = 0;
void* buf = NULL;
FILE *in_ptr = NULL;
long opt_compress_level = Z_DEFAULT_COMPRESSION;
zipFile zf;
zip_fileinfo zi;
PRINT_INFO("LIBBMDZLIBINF Compressing file(s) to %s\n",out);
/******************************/
/* walidacja parametrow */
/******************************/
if (in==NULL)
{
return ZLIB_DECOMP_NO_FILES_FOR_COMPRESSION;
}
for (i=0; i<in_count; i++)
{
if (in[i]==NULL)
{
return ZLIB_DECOMP_NO_FILES_FOR_COMPRESSION;
}
}
if (out==NULL)
{
return ZLIB_DECOMP_NO_OUTPUT_FILE;
}
/******************************************/
/* ustawienie poziomu konmpresji (1-9) */
/******************************************/
opt_compress_level = 9;
/************************************************/
/* sprawdzenie, czy pliki wejsciowe istnieja */
/************************************************/
for (i=0; i<in_count; i++)
{
in_ptr=fopen(in[i],"rb");
if (in_ptr==NULL)
{
return ZLIB_COMP_SRC_FILE_OPEN_ERROR;
}
else
{
fclose(in_ptr);
}
}
buf=(void*)malloc(WRITEBUFFERSIZE);
/************************************************/
/* otwarcie pliku zip do zapisu archiwum */
/************************************************/
zf=zipOpen(out,0);
if (zf == NULL)
{
return ZLIB_COMP_DST_FILE_OPEN_ERROR;
}
/************************************************************/
/* dolaczenie wszystkich plikow z listy do archiwum */
/************************************************************/
for (i=0; i<in_count; i++)
{
/******************************************/
/* pobranie informacji o czasie pliku */
/******************************************/
zi.tmz_date.tm_sec = 0;
zi.tmz_date.tm_min = 0;
zi.tmz_date.tm_hour = 0;
zi.tmz_date.tm_mday = 0;
zi.tmz_date.tm_mon = 0;
zi.tmz_date.tm_year = 0;
zi.dosDate = 0;
zi.internal_fa = 0;
zi.external_fa = 0;
filetime(in[i], &zi.tmz_date, &zi.dosDate);
/******************************************/
/* stworzenie nowego pliku w archiwum */
/******************************************/
status=zipOpenNewFileInZip( zf,
in[i],
&zi,
NULL,
0,
NULL,
0,
NULL,
(opt_compress_level != 0) ? Z_DEFLATED : 0,
opt_compress_level);
if (status!=ZIP_OK)
{
continue;
}
/************************************************************/
/* otwarcie pliku zrodlowego dodawanego do archiwum */
/************************************************************/
in_ptr=fopen(in[i],"rb");
if (in_ptr==NULL)
{
continue;
}
do
{
status=ZIP_OK;
/************************************/
/* odczyt z pliku zrodlowego */
/************************************/
size_read=(int)fread(buf,1,WRITEBUFFERSIZE,in_ptr);
if (size_read < WRITEBUFFERSIZE)
{
if (feof(in_ptr)==0)
{
PRINT_ERROR("LIBBMDZLIBERR Error in reading file %s.\n\tError: .\n\tError=%i\n",in[i],-1);
status=-1;
}
}
/************************************/
/* zapis do pliku w archiwum zip */
/************************************/
if (size_read>0)
{
status=zipWriteInFileInZip(zf,buf,size_read);
if (status<0)
{
PRINT_ERROR("LIBBMDZLIBERR Error in writing file %s to archive %s.\n\tError: .\n\tError=%i\n",in[i],out,-1);
}
}
} while ((status==ZIP_OK) && (size_read>0));
/************************************************/
/* zamkniecie deskryptora pliku zrodlowego */
/************************************************/
fclose(in_ptr);
if (status<0)
{
status=ZIP_ERRNO;
}
else
{
/******************************************/
/* zamkniecie pliku w archiwum zip */
/******************************************/
status=zipCloseFileInZip(zf);
if (status!=ZIP_OK)
{
PRINT_ERROR("LIBBMDZLIBERR Error in closing file %s in archive.\n\tError: .\n\tError=%i\n",in[i],-1);
}
}
}
/************************************************************/
/* zamkniecie pliku zip calego spakowanego archiwum */
/************************************************************/
zipClose(zf,NULL);
/******************/
/* porzadki */
/******************/
free(buf);
return BMD_OK;
}
int _compress(const char** srcs, int src_num, const char** srcspath, int srcpath_num,
const char* dst, int level, const char* password, int exclude_path, PyObject* progress)
{
zipFile zf = NULL;
int size_buf = WRITEBUFFERSIZE;
int opt_overwrite = APPEND_STATUS_CREATE;
int err = ZIP_OK;
int errclose = 0;
int i;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc = {0};
#endif
void* buf = NULL;
buf = (void*)malloc(size_buf);
if (buf == NULL)
{
pyerr_msg = PyErr_Format(PyExc_MemoryError, "could not allocate memory");
return ZIP_ERRNO;
}
if (srcpath_num > 0)
assert(src_num == srcpath_num);
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
zf = zipOpen2_64(dst, opt_overwrite, NULL, &ffunc);
#else
zf = zipOpen64(dst, opt_overwrite);
#endif
if (zf == NULL)
{
pyerr_msg = PyErr_Format(PyExc_IOError, "error opening %s", dst);
err = ZIP_ERRNO;
}
for (i = 0; i < src_num && (err == ZIP_OK); i++) {
FILE *fin = NULL;
int size_read = 0;
const char* filenameinzip = srcs[i];
const char* filepathnameinzip;
const char *savefilenameinzip;
const char *savefilepathnameinzip = NULL;
char *fullpathfileinzip = NULL;
unsigned long crcFile = 0;
int zip64 = 0;
zip_fileinfo zi;
memset(&zi, 0, sizeof(zip_fileinfo));
if (srcpath_num > 0)
filepathnameinzip = srcspath[i];
/* Get information about the file on disk so we can store it in zip */
filetime(filenameinzip, &zi.tmz_date, &zi.dosDate);
if ((password != NULL) && (err == ZIP_OK))
err = get_file_crc(filenameinzip, buf, size_buf, &crcFile);
zip64 = is_large_file(filenameinzip);
/* Construct the filename that our file will be stored in the zip as.
The path name saved, should not include a leading slash.
If it did, windows/xp and dynazip couldn't read the zip file. */
savefilenameinzip = filenameinzip;
while (savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/')
savefilenameinzip++;
if (srcpath_num > 0) {
savefilepathnameinzip = filepathnameinzip;
while (savefilepathnameinzip[0] == '\\' || savefilepathnameinzip[0] == '/')
savefilepathnameinzip++;
}
/* Should the file be stored with any path info at all? */
if (exclude_path)
{
const char *tmpptr = NULL;
const char *lastslash = NULL;
for (tmpptr = savefilenameinzip; *tmpptr; tmpptr++)
{
if (*tmpptr == '\\' || *tmpptr == '/')
lastslash = tmpptr;
}
if (lastslash != NULL)
savefilenameinzip = lastslash + 1; // base filename follows last slash.
if (srcpath_num > 0) {
/* prepend savefilepathnameinzip for each savefilenameinzip */
const char * slash;
#if (defined(_WIN32))
const char default_slash = '\\';
#else
const char default_slash = '/';
#endif
size_t extra_len = 0;
size_t filename_len = strlen(savefilenameinzip);
size_t filepathname_len = strlen(savefilepathnameinzip);
/* look for slash used in filepath */
slash = strchr(savefilepathnameinzip, '/');
if (slash == NULL) {
slash = strchr(savefilepathnameinzip, '\\');
if (slash == NULL) {
// no slash found.. use default
slash = &default_slash;
}
}
if (savefilepathnameinzip[filepathname_len-1] != *slash)
extra_len = 1;
/* allocate buffer */
fullpathfileinzip = (char *)malloc(filename_len + filepathname_len + extra_len + 1);
if (fullpathfileinzip == NULL) {
free(buf);
pyerr_msg = PyErr_Format(PyExc_MemoryError, "error allocating memory on minizip compress");
return ZIP_INTERNALERROR;
}
strncpy(fullpathfileinzip, savefilepathnameinzip, filepathname_len);
if (extra_len)
fullpathfileinzip[filepathname_len] = *slash;
strncpy(fullpathfileinzip + filepathname_len + extra_len, savefilenameinzip, filename_len);
/* terminate string */
fullpathfileinzip[filename_len + filepathname_len + extra_len] = '\0';
/* set pointer */
savefilenameinzip = fullpathfileinzip;
}
}
/* Add to zip file */
err = zipOpenNewFileInZip3_64(zf, savefilenameinzip, &zi,
NULL, 0, NULL, 0, NULL /* comment*/,
(level != 0) ? Z_DEFLATED : 0, level, 0,
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
password, crcFile, zip64);
if (err != ZIP_OK) {
pyerr_msg = PyErr_Format(PyExc_IOError, "error in opening %s in zipfile (%d)", filenameinzip, err);
err = ZIP_ERRNO;
}
else
{
fin = FOPEN_FUNC(filenameinzip, "rb");
if (fin == NULL)
{
pyerr_msg = PyErr_Format(PyExc_IOError, "error in opening %s for reading", filenameinzip);
err = ZIP_ERRNO;
}
}
if (err == ZIP_OK)
{
/* Read contents of file and write it to zip */
do
{
size_read = (int)fread(buf, 1, size_buf, fin);
if ((size_read < size_buf) && (feof(fin) == 0))
{
pyerr_msg = PyErr_Format(PyExc_IOError, "error in reading %s", filenameinzip);
err = ZIP_ERRNO;
}
if (0 < size_read)
{
err = zipWriteInFileInZip(zf, buf, size_read);
if (err < 0) {
pyerr_msg = PyErr_Format(PyExc_IOError, "error in writing %s in the zipfile (%d)", filenameinzip, err);
err = ZIP_ERRNO;
}
}
}
while ((err == ZIP_OK) && (size_read > 0));
}
if (fin)
fclose(fin);
if (err == ZIP_OK)
{
err = zipCloseFileInZip(zf);
if (err != ZIP_OK) {
pyerr_msg = PyErr_Format(PyExc_IOError, "error in closing %s in the zipfile (%d)", filenameinzip, err);
err = ZIP_ERRNO;
}
}
if (progress != NULL)
{
PyObject* args = Py_BuildValue("(I)", i + 1);
PyObject* result = PyObject_CallObject(progress, args);
if (PyErr_Occurred()) // Ignore errors in the callback, don't want them to crash this c module
{
PyErr_Clear();
}
Py_XDECREF(result);
Py_XDECREF(args);
}
if(srcpath_num > 0 && fullpathfileinzip)
free(fullpathfileinzip);
}
errclose = zipClose(zf, NULL);
if (errclose != ZIP_OK) {
pyerr_msg = PyErr_Format(PyExc_IOError, "error in closing %s (%d)", dst, errclose);
err = ZIP_ERRNO;
}
free(buf);
return err;
}
extern "C" bool ArchAddFileW(HZIP hZip,WCHAR *pstrSourceFile,WCHAR *pstrDestFile)
{
bool r=false;
if ((hZip) && (((ZIPCOMPRESSION *)hZip)->bHandleType == HT_COMPRESSOR) && (pstrSourceFile) && (pstrDestFile))
{
int lDest,lSrc;
if (((lDest=lstrlenW(pstrDestFile)) < MAX_PATH-1) && ((lSrc=lstrlenW(pstrSourceFile)) < MAX_PATH-1))
{
ZIPCOMPRESSION *p=(ZIPCOMPRESSION *)hZip;
char *file=UnicodeToOemEx(pstrDestFile,lDest);
if (file)
{
void *buf=_alloc(INT_BUF_SIZE);
if (buf)
{
p->bInMem=false;
zip_fileinfo zi={0};
filetime(pstrSourceFile,&zi.tmz_date,&zi.dosDate);
char *lpPassword=NULL;
unsigned long crcFile=0;
if (p->bEncrypted)
{
getFileCrc(pstrSourceFile,buf,INT_BUF_SIZE,&crcFile);
lpPassword=p->szPassword;
}
int err=zipOpenNewFileInZip3_64(p->hZip,file,&zi,NULL,0,NULL,0,NULL,(p->dwCompLevel>0) ? Z_DEFLATED:0,p->dwCompLevel,0,-MAX_WBITS,DEF_MEM_LEVEL,Z_DEFAULT_STRATEGY,lpPassword,crcFile,0);
if (err == ZIP_OK)
{
HANDLE fin=CreateFileW(pstrSourceFile,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
if (fin != INVALID_HANDLE_VALUE)
{
unsigned long size_read = 0;
do
{
err=ZIP_OK;
ReadFile(fin,buf,INT_BUF_SIZE,&size_read,0);
if (size_read < INT_BUF_SIZE)
{
if (!_feof(fin))
err=ZIP_ERRNO;
}
if (size_read>0)
err=zipWriteInFileInZip(p->hZip,buf,size_read);
}
while ((err == ZIP_OK) && (size_read>0));
SysCloseHandle(fin);
if (err<0)
err=ZIP_ERRNO;
else
{
err=zipCloseFileInZip(p->hZip);
r=true;
}
}
}
MemFree(buf);
}
}
MemFree(file);
}
}
else
ArchSetLastError(ARCH_INVALID_PARAMETER);
return r;
}
int sbbs_t::exec_misc(csi_t* csi, char *path)
{
char str[512],tmp[512],buf[1025],ch,op,*p,**pp,**pp1,**pp2;
ushort w;
uint i=0,j;
long l,*lp=NULL,*lp1=NULL,*lp2=NULL;
void *vp;
struct dirent *de;
struct tm tm;
switch(*(csi->ip++)) {
case CS_VAR_INSTRUCTION:
switch(*(csi->ip++)) { /* sub-op-code stored as next byte */
case PRINT_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp || !*pp) {
lp=getintvar(csi,*(long *)csi->ip);
if(lp)
bprintf("%ld",*lp); }
else
putmsg(cmdstr(*pp,path,csi->str,buf)
,P_SAVEATR|P_NOABORT|P_NOATCODES);
csi->ip+=4;
return(0);
case VAR_PRINTF:
case VAR_PRINTF_LOCAL:
op=*(csi->ip-1);
p=format_string(this, csi);
if(op==VAR_PRINTF)
putmsg(cmdstr(p,path,csi->str,buf),P_SAVEATR|P_NOABORT|P_NOATCODES);
else {
if(online==ON_LOCAL)
eprintf(LOG_INFO,"%s",cmdstr(p,path,csi->str,buf));
else
lputs(LOG_INFO,cmdstr(p,path,csi->str,buf));
}
free(p);
return(0);
case SHOW_VARS:
bprintf("shell str=(%08lX) %s\r\n"
,csi->str,csi->str);
for(i=0;i<csi->str_vars;i++)
bprintf("local str[%d]=(%08lX) (%08lX) %s\r\n"
,i,csi->str_var_name[i]
,csi->str_var[i]
,csi->str_var[i]);
for(i=0;i<csi->int_vars;i++)
bprintf("local int[%d]=(%08lX) (%08lX) %ld\r\n"
,i,csi->int_var_name[i]
,csi->int_var[i]
,csi->int_var[i]);
for(i=0;i<global_str_vars;i++)
bprintf("global str[%d]=(%08lX) (%08lX) %s\r\n"
,i,global_str_var_name[i]
,global_str_var[i]
,global_str_var[i]);
for(i=0;i<global_int_vars;i++)
bprintf("global int[%d]=(%08lX) (%08lX) %ld\r\n"
,i,global_int_var_name[i]
,global_int_var[i]
,global_int_var[i]);
return(0);
case DEFINE_STR_VAR:
if(getstrvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
csi->str_vars++;
csi->str_var=(char **)realloc(csi->str_var
,sizeof(char *)*csi->str_vars);
csi->str_var_name=(long *)realloc(csi->str_var_name
,sizeof(long)*csi->str_vars);
if(csi->str_var==NULL
|| csi->str_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local str var"
,sizeof(char *)*csi->str_vars);
if(csi->str_var_name) {
free(csi->str_var_name);
csi->str_var_name=0; }
if(csi->str_var) {
free(csi->str_var);
csi->str_var=0; }
csi->str_vars=0; }
else {
csi->str_var_name[csi->str_vars-1]=*(long *)csi->ip;
csi->str_var[csi->str_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_INT_VAR:
if(getintvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
csi->int_vars++;
csi->int_var=(long *)realloc(csi->int_var
,sizeof(char *)*csi->int_vars);
csi->int_var_name=(long *)realloc(csi->int_var_name
,sizeof(long)*csi->int_vars);
if(csi->int_var==NULL
|| csi->int_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local int var"
,sizeof(char *)*csi->int_vars);
if(csi->int_var_name) {
free(csi->int_var_name);
csi->int_var_name=0; }
if(csi->int_var) {
free(csi->int_var);
csi->int_var=0; }
csi->int_vars=0; }
else {
csi->int_var_name[csi->int_vars-1]=*(long *)csi->ip;
csi->int_var[csi->int_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_GLOBAL_STR_VAR:
if(getstrvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
global_str_vars++;
global_str_var=(char **)realloc(global_str_var
,sizeof(char *)*global_str_vars);
global_str_var_name=(long *)realloc(global_str_var_name
,sizeof(long)*global_str_vars);
if(global_str_var==NULL
|| global_str_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"global str var"
,sizeof(char *)*global_str_vars);
if(global_str_var_name) {
free(global_str_var_name);
global_str_var_name=0; }
if(global_str_var) {
free(global_str_var);
global_str_var=0; }
global_str_vars=0; }
else {
global_str_var_name[global_str_vars-1]=
*(long *)csi->ip;
global_str_var[global_str_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_GLOBAL_INT_VAR:
if(getintvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
global_int_vars++;
global_int_var=(long *)realloc(global_int_var
,sizeof(char *)*global_int_vars);
global_int_var_name=(long *)realloc(global_int_var_name
,sizeof(long)*global_int_vars);
if(global_int_var==NULL
|| global_int_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local int var"
,sizeof(char *)*global_int_vars);
if(global_int_var_name) {
free(global_int_var_name);
global_int_var_name=0; }
if(global_int_var) {
free(global_int_var);
global_int_var=0; }
global_int_vars=0; }
else {
global_int_var_name[global_int_vars-1]
=*(long *)csi->ip;
global_int_var[global_int_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case SET_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp)
*pp=copystrvar(csi,*pp
,cmdstr((char *)csi->ip,path,csi->str,buf));
while(*(csi->ip++)); /* Find NULL */
return(0);
case SET_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(lp)
*lp=*(long *)csi->ip;
csi->ip+=4; /* Skip value */
return(0);
case COMPARE_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp)
csi->logic=stricmp(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf));
else { /* Uninitialized str var */
if(*(csi->ip)==0) /* Blank static str */
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE; }
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRSTR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp && strstr(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf)))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRNCMP_VAR:
i=*csi->ip++;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp)
csi->logic=strnicmp(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf),i);
else
csi->logic=LOGIC_FALSE;
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRNCMP_VARS:
i=*csi->ip++;
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2)
csi->logic=strnicmp(*pp1,*pp2,i);
else
csi->logic=LOGIC_FALSE;
return(0);
case STRSTR_VARS:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2 && strstr(*pp1,*pp2))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case COMPARE_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
l=*(long *)csi->ip;
csi->ip+=4; /* Skip static value */
if(!lp) { /* Unknown variable */
csi->logic=LOGIC_FALSE;
return(0); }
if(*lp>l)
csi->logic=LOGIC_GREATER;
else if(*lp<l)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0);
case COMPARE_VARS:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(((!pp1 || !*pp1) && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
if(pp1 && pp2) /* Both unitialized or blank */
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0); }
if(pp1) { /* ASCII */
if(!pp2) {
ultoa(*lp2,tmp,10);
csi->logic=stricmp(*pp1,tmp); }
else
csi->logic=stricmp(*pp1,*pp2);
return(0); }
/* Binary */
if(!lp2) {
l=strtol(*pp2,0,0);
if(*lp1>l)
csi->logic=LOGIC_GREATER;
else if(*lp1<l)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0); }
if(*lp1>*lp2)
csi->logic=LOGIC_GREATER;
else if(*lp1<*lp2)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0);
case COPY_VAR:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if((!pp1 && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(pp1) { /* ASCII */
if(!pp2)
ultoa(*lp2,tmp,10);
else
strcpy(tmp,*pp2);
*pp1=copystrvar(csi,*pp1,tmp);
return(0); }
if(!lp2)
*lp1=strtol(*pp2,0,0);
else
*lp1=*lp2;
return(0);
case SWAP_VARS:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(((!pp1 || !*pp1) && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(pp1) { /* ASCII */
if(!pp2) {
if(!strnicmp(*pp2,"0x",2)) {
l=strtol((*pp1)+2,0,16);
ultoa(*lp2,tmp,16); }
else {
l=atol(*pp1);
ultoa(*lp2,tmp,10); }
*pp1=copystrvar(csi,*pp1,tmp);
*lp2=l; }
else {
p=*pp1;
*pp1=*pp2;
*pp2=p; }
return(0); }
/* Binary */
if(!lp2) {
if(!strnicmp(*pp2,"0x",2)) {
l=strtol((*pp2)+2,0,16);
ultoa(*lp1,tmp,16); }
else {
l=atol(*pp2);
ultoa(*lp1,tmp,10); }
*pp2=copystrvar(csi,*pp2,tmp);
*lp1=l; }
else {
l=*lp1;
*lp1=*lp2;
*lp2=l; }
return(0);
case CAT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
strcpy(tmp,(char *)csi->ip);
while(*(csi->ip++));
if(pp && *pp)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp==sysvar_p[i])
break;
if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
if(*pp)
*pp=(char *)realloc(*pp,strlen(*pp)+strlen(tmp)+1);
else
*pp=(char *)realloc(*pp,strlen(tmp)+1); }
if(pp && *pp)
strcat(*pp,tmp);
return(0);
case CAT_STR_VARS:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip dest variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip source variable name */
/* Concatenate an int var to a str var (as char) */
if(pp2==NULL) {
lp=getintvar(csi,*(long *)(csi->ip-4));
if(lp==NULL) {
csi->logic=LOGIC_FALSE;
return(0);
}
pp=pp1;
tmp[0]=(uchar)*lp;
tmp[1]=0;
if(pp && *pp)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp==sysvar_p[i])
break;
if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
if(*pp)
*pp=(char *)realloc(*pp,strlen(*pp)+strlen(tmp)+1);
else
*pp=(char *)realloc(*pp,strlen(tmp)+1); }
if(pp && *pp)
strcat(*pp,tmp);
return(0);
}
if(!pp1 || !pp2 || !*pp2) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(*pp1)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp1==sysvar_p[i])
break;
if(*pp1!=csi->str && (!*pp1 || i==MAX_SYSVARS)) {
if(*pp1)
*pp1=(char *)realloc(*pp1,strlen(*pp1)+strlen(*pp2)+1);
else
*pp1=(char *)realloc(*pp1,strlen(*pp2)+1); }
strcat(*pp1,*pp2);
return(0);
case FORMAT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
p=format_string(this, csi);
cmdstr(p,path,csi->str,str);
if(pp)
*pp=copystrvar(csi,*pp,str);
free(p);
return(0);
case FORMAT_TIME_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
strcpy(str,(char *)csi->ip);
while(*(csi->ip++)); /* Find NULL */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && lp) {
if(localtime_r((time_t *)lp,&tm)!=NULL) {
strftime(buf,128,str,&tm);
*pp=copystrvar(csi,*pp,buf);
}
}
return(0);
case TIME_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
strcpy(str,timestr((time_t *)lp));
*pp=copystrvar(csi,*pp,str); }
return(0);
case DATE_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
unixtodstr(&cfg,*lp,str);
*pp=copystrvar(csi,*pp,str); }
return(0);
case SECOND_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
sectostr(*lp,str);
*pp=copystrvar(csi,*pp,str); }
return(0);
case STRUPR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strupr(*pp);
return(0);
case STRLWR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strlwr(*pp);
return(0);
case TRUNCSP_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
truncsp(*pp);
return(0);
case STRIP_CTRL_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strip_ctrl(*pp);
return(0);
case ADD_INT_VAR:
case SUB_INT_VAR:
case MUL_INT_VAR:
case DIV_INT_VAR:
case MOD_INT_VAR:
case AND_INT_VAR:
case OR_INT_VAR:
case NOT_INT_VAR:
case XOR_INT_VAR:
i=*(csi->ip-1);
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
if(!lp)
return(0);
switch(i) {
case ADD_INT_VAR:
*lp+=l;
break;
case SUB_INT_VAR:
*lp-=l;
break;
case MUL_INT_VAR:
*lp*=l;
break;
case DIV_INT_VAR:
*lp/=l;
break;
case MOD_INT_VAR:
*lp%=l;
break;
case AND_INT_VAR:
*lp&=l;
break;
case OR_INT_VAR:
*lp|=l;
break;
case NOT_INT_VAR:
*lp&=~l;
break;
case XOR_INT_VAR:
*lp^=l;
break; }
return(0);
case COMPARE_ANY_BITS:
case COMPARE_ALL_BITS:
i=*(csi->ip-1);
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(!lp)
return(0);
if(i==COMPARE_ANY_BITS) {
if(((*lp)&l)!=0)
csi->logic=LOGIC_TRUE;
} else {
if(((*lp)&l)==l)
csi->logic=LOGIC_TRUE;
}
return(0);
case ADD_INT_VARS:
case SUB_INT_VARS:
case MUL_INT_VARS:
case DIV_INT_VARS:
case MOD_INT_VARS:
case AND_INT_VARS:
case OR_INT_VARS:
case NOT_INT_VARS:
case XOR_INT_VARS:
i=*(csi->ip-1);
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
if(!lp2) {
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp || !*pp)
return(0);
l=strtol(*pp,0,0); }
else
l=*lp2;
csi->ip+=4;
if(!lp1)
return(0);
switch(i) {
case ADD_INT_VARS:
*lp1+=l;
break;
case SUB_INT_VARS:
*lp1-=l;
break;
case MUL_INT_VARS:
*lp1*=l;
break;
case DIV_INT_VARS:
*lp1/=l;
break;
case MOD_INT_VARS:
*lp1%=l;
break;
case AND_INT_VARS:
*lp1&=l;
break;
case OR_INT_VARS:
*lp1|=l;
break;
case NOT_INT_VARS:
*lp1&=~l;
break;
case XOR_INT_VARS:
*lp1^=l;
break; }
return(0);
case RANDOM_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
if(lp)
*lp=sbbs_random(l);
return(0);
case TIME_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp)
*lp=time(NULL);
return(0);
case DATE_STR_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && pp && *pp)
*lp=dstrtounix(&cfg,*pp);
return(0);
case STRLEN_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=strlen(*pp);
else
*lp=0; }
return(0);
case CRC16_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=crc16(*pp,0);
else
*lp=0; }
return(0);
case CRC32_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=crc32(*pp,0);
else
*lp=0; }
return(0);
case CHKSUM_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
*lp=0;
if(pp && *pp) {
i=0;
while(*((*pp)+i))
*lp+=(uchar)*((*pp)+(i++)); } }
return(0);
case FLENGTH_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=flength(*pp);
else
*lp=0; }
return(0);
case FTIME_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=fdate(*pp);
else
*lp=0; }
return(0);
case CHARVAL_TO_INT:
case COPY_FIRST_CHAR: // duplicate functionality - doh!
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=**pp;
else
*lp=0; }
return(0);
case GETSTR_VAR:
case GETLINE_VAR:
case GETNAME_VAR:
case GETSTRUPR_VAR:
case GETSTR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(csi->ip++);
csi->logic=LOGIC_FALSE;
switch(*(csi->ip-6)) {
case GETNAME_VAR:
getstr(buf,i,K_UPRLWR);
break;
case GETSTRUPR_VAR:
getstr(buf,i,K_UPPER);
break;
case GETLINE_VAR:
getstr(buf,i,K_LINE);
break;
case GETSTR_MODE:
l=*(long *)csi->ip;
csi->ip+=4;
if(l&K_EDIT) {
if(pp && *pp)
strcpy(buf,*pp);
else
buf[0]=0; }
getstr(buf,i,l);
break;
default:
getstr(buf,i,0); }
if(sys_status&SS_ABORT)
return(0);
if(pp) {
*pp=copystrvar(csi,*pp,buf);
csi->logic=LOGIC_TRUE; }
return(0);
case GETNUM_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)csi->ip;
csi->ip+=2;
csi->logic=LOGIC_FALSE;
l=getnum(i);
if(!pp && !lp)
return(0);
if(pp) {
if(l<=0)
str[0]=0;
else
ultoa(l,str,10);
*pp=copystrvar(csi,*pp,str);
csi->logic=LOGIC_TRUE;
return(0); }
if(lp) {
*lp=l;
csi->logic=LOGIC_TRUE; }
return(0);
case SHIFT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(csi->ip++);
if(!pp || !*pp)
return(0);
if(strlen(*pp)>=i)
memmove(*pp,*pp+i,strlen(*pp)+1);
return(0);
case SHIFT_TO_FIRST_CHAR:
case SHIFT_TO_LAST_CHAR:
i=*(csi->ip-1);
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
ch=*(csi->ip++);
csi->logic=LOGIC_FALSE;
if(!pp || !*pp)
return(0);
if(i==SHIFT_TO_FIRST_CHAR)
p=strchr(*pp,ch);
else /* _TO_LAST_CHAR */
p=strrchr(*pp,ch);
if(p==NULL)
return(0);
csi->logic=LOGIC_TRUE;
i=p-*pp;
if(i>0)
memmove(*pp,*pp+i,strlen(p)+1);
return(0);
case CHKFILE_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && fexistcase(cmdstr(*pp,path,csi->str,buf)))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case PRINTFILE_VAR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)(csi->ip);
csi->ip+=2;
if(pp && *pp)
printfile(*pp,i);
return(0);
case PRINTTAIL_VAR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)(csi->ip);
csi->ip+=2;
j=*csi->ip;
csi->ip++;
if(pp && *pp)
printtail(*pp,j,i);
return(0);
case TELNET_GATE_VAR:
l=*(ulong *)(csi->ip); // Mode
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
telnet_gate(*pp,l);
return(0);
case TELNET_GATE_STR:
l=*(ulong *)(csi->ip); // Mode
csi->ip+=4;
strcpy(str,(char *)csi->ip);
while(*(csi->ip++)); /* Find NULL */
telnet_gate(str,l);
return(0);
case COPY_CHAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(pp==NULL)
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp==NULL && lp!=NULL)
*lp=csi->cmd;
else if(pp!=NULL) {
sprintf(tmp,"%c",csi->cmd);
*pp=copystrvar(csi,*pp,tmp);
}
return(0);
case COMPARE_FIRST_CHAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
ch=*(csi->ip++); /* char const */
if(pp==NULL || *pp==NULL)
csi->logic=LOGIC_FALSE;
else {
if(**pp==ch)
csi->logic=LOGIC_EQUAL;
else if(**pp>ch)
csi->logic=LOGIC_GREATER;
else
csi->logic=LOGIC_LESS;
}
return(0);
case SEND_FILE_VIA:
case RECEIVE_FILE_VIA:
j=*(csi->ip-1);
ch=*(csi->ip++); /* Protocol */
cmdstr((char *)csi->ip,csi->str,csi->str,str);
while(*(csi->ip++)); /* Find NULL */
for(i=0;i<cfg.total_prots;i++)
if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
break;
csi->logic=LOGIC_FALSE;
if(i<cfg.total_prots)
if(protocol(cfg.prot[i],j==SEND_FILE_VIA ? XFER_DOWNLOAD : XFER_UPLOAD
,str,str,true)==0)
csi->logic=LOGIC_TRUE;
return(0);
case SEND_FILE_VIA_VAR:
case RECEIVE_FILE_VIA_VAR:
j=*(csi->ip-1);
ch=*(csi->ip++); /* Protocol */
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
for(i=0;i<cfg.total_prots;i++)
if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
break;
csi->logic=LOGIC_FALSE;
if(!pp || !(*pp))
return(0);
if(i<cfg.total_prots)
if(protocol(cfg.prot[i]
,j==SEND_FILE_VIA_VAR ? XFER_DOWNLOAD : XFER_UPLOAD
,*pp,*pp,true)==0)
csi->logic=LOGIC_TRUE;
return(0);
case MATCHUSER:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=matchuser(&cfg, *pp, TRUE /*sysop_alias*/);
else
*lp=0;
}
return(0);
default:
errormsg(WHERE,ERR_CHK,"var sub-instruction",*(csi->ip-1));
return(0); }
case CS_FIO_FUNCTION:
switch(*(csi->ip++)) { /* sub-op-code stored as next byte */
case FIO_OPEN:
case FIO_OPEN_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
w=*(ushort *)csi->ip;
csi->ip+=2;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-7)==FIO_OPEN) {
cmdstr((char *)csi->ip,path,csi->str,str);
while(*(csi->ip++)); } /* skip filename */
else {
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!pp || !*pp)
return(0);
strcpy(str,*pp); }
if(csi->files>=MAX_FOPENS)
return(0);
if(lp) {
/* Access flags are not cross-platform, so convert */
i=0;
if(w&0x001) i|=O_RDONLY;
if(w&0x002) i|=O_WRONLY;
if(w&0x004) i|=O_RDWR;
if(w&0x040) i|=O_DENYNONE;
if(w&0x100) i|=O_CREAT;
if(w&0x200) i|=O_TRUNC;
if(w&0x400) i|=O_EXCL;
if(w&0x800) i|=O_APPEND;
*lp=(long)fnopen((int *)&j,str,i);
if(*lp) {
for(i=0;i<csi->files;i++)
if(!csi->file[i])
break;
csi->file[i]=(FILE *)*lp;
if(i==csi->files)
csi->files++;
csi->logic=LOGIC_TRUE; } }
return(0);
case FIO_CLOSE:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && *lp) {
csi->logic=fclose((FILE *)*lp);
for(i=0;i<csi->files;i++)
if(csi->file[i]==(FILE *)*lp)
csi->file[i]=0;
*lp=0;
}
else
csi->logic=LOGIC_FALSE;
return(0);
case FIO_FLUSH:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && *lp)
csi->logic=fflush((FILE *)*lp);
else
csi->logic=LOGIC_FALSE;
return(0);
case FIO_READ:
case FIO_READ_VAR:
lp1=getintvar(csi,*(long *)csi->ip); /* Handle */
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-9)==FIO_READ) {
i=*(short *)csi->ip;
csi->ip+=2; /* Length */ }
else { /* FIO_READ_VAR */
vp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!vp)
return(0);
i=*(short *)vp; }
if(i>sizeof(buf)-1)
i=sizeof(buf)-1;
if(!lp1 || !(*lp1) || (!pp && !lp2))
return(0);
if(pp) {
if(i<1) {
if(*pp && **pp)
i=strlen(*pp);
else
i=128; }
if((j=fread(buf,1,i,(FILE *)*lp1))==i)
csi->logic=LOGIC_TRUE;
buf[j]=0;
if(csi->etx) {
p=strchr(buf,csi->etx);
if(p) *p=0; }
*pp=copystrvar(csi,*pp,buf); }
else {
*lp2=0;
if(i>4 || i<1) i=4;
if(fread(lp2,1,i,(FILE *)*lp1)==i)
csi->logic=LOGIC_TRUE; }
return(0);
case FIO_READ_LINE:
lp1=getintvar(csi,*(long *)csi->ip); /* Handle */
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(!lp1 || !(*lp1) || feof((FILE *)*lp1) || (!pp && !lp2))
return(0);
csi->logic=LOGIC_TRUE;
for(i=0;i<sizeof(buf)-1;i++) {
if(!fread(buf+i,1,1,(FILE *)*lp1))
break;
if(*(buf+i)==LF) {
i++;
break; } }
buf[i]=0;
if(csi->etx) {
p=strchr(buf,csi->etx);
if(p) *p=0; }
if(pp)
*pp=copystrvar(csi,*pp,buf);
else
*lp2=strtol(buf,0,0);
return(0);
case FIO_WRITE:
case FIO_WRITE_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-9)==FIO_WRITE) {
i=*(short *)csi->ip;
csi->ip+=2; /* Length */ }
else { /* FIO_WRITE_VAR */
vp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!vp)
return(0);
i=*(short *)vp; }
if(i>sizeof(buf)-1)
i=sizeof(buf)-1;
if(!lp1 || !(*lp1) || (!pp && !lp2) || (pp && !*pp))
return(0);
if(pp) {
j=strlen(*pp);
if(i<1) i=j;
if(j>i) j=i;
if(fwrite(*pp,1,j,(FILE *)*lp1)!=j)
csi->logic=LOGIC_FALSE;
else {
if(j<i) {
memset(buf,csi->etx,i-j);
fwrite(buf,1,i-j,(FILE *)*lp1);
}
csi->logic=LOGIC_TRUE;
}
} else {
if(i<1 || i>4) i=4;
if(fwrite(lp2,1,i,(FILE *)*lp1)==i)
csi->logic=LOGIC_TRUE; }
return(0);
case FIO_GET_LENGTH:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=filelength(fileno((FILE *)*lp1));
return(0);
case FIO_GET_TIME:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=filetime(fileno((FILE *)*lp1));
return(0);
case FIO_SET_TIME:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
#if 0 /* ftime */
if(lp1 && *lp1 && lp2) {
ft=unixtoftime(*lp2);
setftime(fileno((FILE *)*lp1),&ft); }
#endif
return(0);
case FIO_EOF:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(lp && *lp)
if(ftell((FILE *)*lp)>=filelength(fileno((FILE *)*lp)))
csi->logic=LOGIC_TRUE;
return(0);
case FIO_GET_POS:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=ftell((FILE *)*lp1);
return(0);
case FIO_SEEK:
case FIO_SEEK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_SEEK) {
l=*(long *)csi->ip;
csi->ip+=4; }
else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2) {
csi->ip+=2;
return(0); }
l=*lp2; }
i=*(short *)csi->ip;
csi->ip+=2;
if(lp1 && *lp1)
if(fseek((FILE *)*lp1,l,i)!=-1)
csi->logic=LOGIC_TRUE;
return(0);
case FIO_LOCK:
case FIO_LOCK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_LOCK) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2;
}
if(lp1 && *lp1) {
fflush((FILE *)*lp1);
csi->logic=!lock(fileno((FILE *)*lp1),ftell((FILE*)*lp1),l);
}
return(0);
case FIO_UNLOCK:
case FIO_UNLOCK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_UNLOCK) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2;
}
if(lp1 && *lp1) {
fflush((FILE *)*lp1);
csi->logic=!unlock(fileno((FILE *)*lp1),ftell((FILE*)*lp1),l);
}
return(0);
case FIO_SET_LENGTH:
case FIO_SET_LENGTH_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_SET_LENGTH) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2; }
if(lp1 && *lp1)
csi->logic=chsize(fileno((FILE *)*lp1),l);
return(0);
case FIO_PRINTF:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
p=format_string(this, csi);
if(lp1 && *lp1) {
cmdstr(p,path,csi->str,str);
fwrite(str,1,strlen(str),(FILE *)*lp1);
}
free(p);
return(0);
case FIO_SET_ETX:
csi->etx=*(csi->ip++);
return(0);
case REMOVE_FILE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && remove(*pp)==0)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case RENAME_FILE:
case COPY_FILE:
case MOVE_FILE:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2)
switch(*(csi->ip-9)) {
case RENAME_FILE:
csi->logic=rename(*pp1,*pp2);
break;
case COPY_FILE:
csi->logic=mv(*pp1,*pp2,1);
break;
case MOVE_FILE:
csi->logic=mv(*pp1,*pp2,0);
break; }
else
csi->logic=LOGIC_FALSE;
return(0);
case GET_FILE_ATTRIB:
case SET_FILE_ATTRIB:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && lp) {
if(*(csi->ip-9)==GET_FILE_ATTRIB)
*lp=getfattr(*pp);
else
*lp=CHMOD(*pp,(int)*lp);
}
return(0);
case MAKE_DIR:
case REMOVE_DIR:
case CHANGE_DIR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
switch(*(csi->ip-5)) {
case MAKE_DIR:
csi->logic=MKDIR(*pp);
break;
case REMOVE_DIR:
csi->logic=rmdir(*pp);
break;
case CHANGE_DIR:
csi->logic=chdir(*pp);
break; }
else
csi->logic=LOGIC_FALSE;
return(0);
case OPEN_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(pp && *pp && lp) {
*lp=(long)opendir((char *)*pp);
if(*lp)
csi->logic=LOGIC_TRUE; }
return(0);
case READ_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(pp && lp) {
de=readdir((DIR *)(*lp));
if(de!=NULL) {
csi->logic=LOGIC_TRUE;
*pp=copystrvar(csi,*pp,de->d_name); } }
return(0);
case REWIND_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
rewinddir((DIR *)(*lp));
csi->logic=LOGIC_TRUE; }
else
csi->logic=LOGIC_FALSE;
return(0);
case CLOSE_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && closedir((DIR *)(*lp))==0)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
default:
errormsg(WHERE,ERR_CHK,"fio sub-instruction",*(csi->ip-1));
return(0); }
case CS_NET_FUNCTION:
return(exec_net(csi));
case CS_SWITCH:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp) {
skipto(csi,CS_END_SWITCH);
csi->ip++; }
else {
csi->misc|=CS_IN_SWITCH;
csi->switch_val=*lp; }
return(0);
case CS_CASE:
l=*(long *)csi->ip;
csi->ip+=4;
if(csi->misc&CS_IN_SWITCH && csi->switch_val!=l)
skipto(csi,CS_NEXTCASE);
else
csi->misc&=~CS_IN_SWITCH;
return(0);
case CS_COMPARE_ARS:
i=*(csi->ip++); /* Length of ARS stored as byte before ARS */
csi->logic=!chk_ar(csi->ip,&useron);
csi->ip+=i;
return(0);
case CS_TOGGLE_USER_MISC:
useron.misc^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_MISC,8,ultoa(useron.misc,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_MISC:
if((useron.misc&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_TOGGLE_USER_CHAT:
useron.chat^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_CHAT,8,ultoa(useron.chat,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_CHAT:
if((useron.chat&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_TOGGLE_USER_QWK:
useron.qwk^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_QWK,8,ultoa(useron.qwk,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_QWK:
if((useron.qwk&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_REPLACE_TEXT:
i=*(ushort *)csi->ip;
csi->ip+=2;
i--;
if(i>=TOTAL_TEXT) {
errormsg(WHERE,ERR_CHK,"replace text #",i);
while(*(csi->ip++)); /* Find NULL */
return(0); }
if(text[i]!=text_sav[i] && text[i]!=nulstr)
free(text[i]);
j=strlen(cmdstr((char *)csi->ip,path,csi->str,buf));
if(!j)
text[i]=nulstr;
else
text[i]=(char *)malloc(j+1);
if(!text[i]) {
errormsg(WHERE,ERR_ALLOC,"replacement text",j);
while(*(csi->ip++)); /* Find NULL */
text[i]=text_sav[i];
return(0); }
if(j)
strcpy(text[i],buf);
while(*(csi->ip++)); /* Find NULL */
return(0);
case CS_USE_INT_VAR: // Self-modifying code!
pp=getstrvar(csi,*(long *)csi->ip);
if(pp && *pp)
l=strtol(*pp,0,0);
else {
lp=getintvar(csi,*(long *)csi->ip);
if(lp)
l=*lp;
else
l=0; }
csi->ip+=4; // Variable
i=*(csi->ip++); // Offset
if(i<1 || csi->ip+1+i>=csi->cs+csi->length) {
errormsg(WHERE,ERR_CHK,"offset",i);
csi->ip++;
return(0); }
switch(*(csi->ip++)) { // Length
case sizeof(char):
*(csi->ip+i)=(char)l;
break;
case sizeof(short):
*((short *)(csi->ip+i))=(short)l;
break;
case sizeof(long):
*((long *)(csi->ip+i))=l;
break;
default:
errormsg(WHERE,ERR_CHK,"length",*(csi->ip-1));
break; }
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0); }
}
// Add, update, freshen, or delete zip entries in a zip file. argc; /*
// Number of tokens in command line. argv; /* Command line tokens.
int ZipProcess(struct Globals *pG)
{
int a; // attributes of zip file
ulg c; // start of central directory
struct flist *f; // steps through "found" linked list
int i; // arg counter, root directory flag
int k; // next argument type, marked counter, comment size, entry count
int marks; // replaces k as marked counter
ulg n; // total of entry len's
// int o; /* true if there were any ZEN_OPEN errors
char *p; // steps through option arguments
int r; // temporary variable
ulg t; // file time, length of central directory
// int first_listarg = 0; // index of first arg of "process these files" list
struct zlist *v; // temporary variable
struct zlist **w; // pointer to last link in "zfiles" list
struct zlist *z; // steps through "zfiles" linked list
int altered; // RP 173 counter for altered comments
int DestType; // 1.75 destination drive type
unsigned long TotFiles = 0;
unsigned /* long */__int64 TotSize = 0;
unsigned long KeptCnt = 0; // number of 'kept' files
unsigned __int64 KeptSize = 0; // size of 'kept' files
unsigned long ofs; // current file offset
int fsz; // file size;
int No_File = 0; // 1.75 try if file does not exist
long hi;
// Process arguments
diag("processing lists", pG);
if (pG->verbose)
{
switch (pG->action)
{
case ADD:
diag("action = ADD", pG);
break;
case UPDATE:
diag("action = UPDATE", pG);
break;
case FRESHEN:
diag("action = FRESHEN", pG);
break;
case PURGE:
diag("action = PURGE", pG);
}
// zcount is no. of entries in linked-list
// zfiles is name of the linked-list of filenames for the archive
Inform(pG, 0, IDIAG, "zcount=%d (no. of files in ZIP already)", pG->zcount);
}
// if first_listarg is 0, then we didn't got any fspecs on cmd line
if (pG->doall && (pG->action == UPDATE || pG->action == FRESHEN))
{
// if -update or -freshen with no args, do all, but, when present, apply
// filters
for (z = pG->zfiles; z != NULL; z = z->nxt)
{
z->mark = pG->pcount ? filter(z->zname, pG): 1;
}
}
if ((r = check_dup(pG)) != ZEN_OK)
// remove duplicates in list
return (ziperr(r, pG));
// Check option combinations
// ?????
if (pG->action == PURGE && (pG->dispose || pG->recurse || pG->key))
return (ziperr(ZEN_PARMS12, pG));
if (pG->linkput && pG->dosify)
{
Inform(pG, 0, IWARNING, "can't use -y with -k, -y ignored");
pG->linkput = 0;
}
// AllowGrow is the "allow append" indicator
if (!pG->zcount && ((pG->action == ADD) || (pG->action == UPDATE)))
pG->AllowGrow = 55;
//1; // RP173 - create new file normally
// if zcount is 0, then zipfile doesn't exist, or is empty
if (pG->zcount == 0 && ((pG->action != ADD && pG->action != UPDATE) || !pG
->AllowGrow))
{
// RCV150199 added UPDATE
Inform(pG, 0, IWARNING, "%s: not found or empty", pG->zipfile);
if (pG->zcount)
FREE(pG->zsort);
return 0;
}
if (pG->zcount)
{
FREE(pG->zsort);
pG->zsort = NULL;
}
DestType = DriveType(pG->zipfile);
if (pG->verbose < 0)
Inform(pG, 0, IDIAG, "Destination type = %d", DestType);
// RP - check destination type - if CD set tempath to Windows Temp
if (pG->tempath == NULL && (DestType != DRIVE_FIXED && DestType !=
DRIVE_RAMDISK))
{
unsigned int plen;
plen = GetTempPath(2047, pG->ewemsg);
if (plen && (pG->tempath = (char*)MALLOC(plen + 1)) != NULL)
lstrcpy(pG->tempath, pG->ewemsg);
else
return (ziperr(ZEN_MEM10, pG));
}
// If -b not specified, set temporary path to zipfile path
if (pG->tempath == NULL && ((p = strrchr(pG->zipfile, '\\')) != NULL || (p =
strrchr(pG->zipfile, ':')) != NULL))
{
if (*p == ':')
p++;
if ((pG->tempath = (char*)MALLOC((int)(p - pG->zipfile) + 1)) == NULL)
return (ziperr(ZEN_MEM10, pG));
r = *p;
*p = 0;
lstrcpy(pG->tempath, pG->zipfile);
*p = (char)r;
}
// NOTE: "k" is being redefined below this point. Now, it going to
// track the no. of marked files in the "zfiles" linked list.
// For each marked entry in "zfiles" linked list, if not deleting, check
// if a corresponding "external" file exists. If updating or freshening,
// compare date of "external" file with entry in orig zipfile. Unmark if it
// external file doesn't exist or is too old, else mark it. Entries that
// are marked will cause that file to be rezipped.
diag("checking marked entries", pG);
marks = 0; // Initialize marked count
// zfiles is name of the linked-list of filenames for the archive
#ifdef USE_STRM_INPUT
if (!pG->UseInStream)
#endif
for (z = pG->zfiles; z != NULL; z = z->nxt)
{
if (z->mark)
{
ulg FileAttr;
#ifdef USE_EF_UX_TIME
ztimbuf f_utim, z_utim;
#endif
#ifdef USE_EF_UX_TIME
if (pG->action != PURGE && ((t = filetime(z->name, &FileAttr, (long*)
NULL, &f_utim, pG)) == 0 || t < pG->before || ((pG->action == UPDATE
|| pG->action == FRESHEN) && (get_ef_ux_ztime(z, &z_utim) ?
f_utim.modtime <= z_utim.modtime: t <= z->tim)) || (pG->ArchiveFiles
&& pG->action == FRESHEN && !(FileAttr &A_ARCHIVE))))
{
z->mark = 0;
z->trash = t && t >= pG->before; // delete if -um or -fm
if (pG->verbose)
{
Inform(pG, 0, 0, "%s %s", z->name, z->trash ? "up to date" :
"missing or early");
}
}
else
marks++;
// incr. number of marked entries
#else
if (pG->action != PURGE)
{
t = filetime(z->name, &FileAttr, &fsz /* NULL */, NULL, pG);
// && (
// (t = filetime( z->name, &FileAttr, &fsz /*NULL*/, NULL, pG )) == 0
if ((t == 0 || t < pG->before || ((pG->action == UPDATE || pG->action
== FRESHEN) && t <= z->tim) || (pG->ArchiveFiles && pG->action ==
FRESHEN && !(FileAttr &A_ARCHIVE))) || ( /* (int) */fsz < - 2))
// RP - check size
{
z->mark = 0;
z->trash = (t && t >= pG->before) || ( /* (int) */fsz < - 2);
// delete if -um or -fm
// z->trash = t && t >= pG->before; // delete if -um or -fm
if (pG->verbose)
{
Inform(pG, 0, 0, "%s %s", z->name, z->trash ? (int)fsz < - 2 ?
"now too big" : "up to date": "missing or early");
// z->trash ? "up to date" : "missing or early" );
}
}
else
{
TotSize += fsz;
TotFiles++;
marks++;
}
}
else
// PURGE
marks++;
// incr. number of marked entries
#endif
}
}
#ifdef USE_STRM_INPUT
if (pG->UseInStream)
marks = 1;
#endif
// RP - verify file specified to 'Purge'
if (pG->action == PURGE && !marks)
return (ziperr(ZEN_NONE03, pG));
// Remove entries from "found" linked list if: Action is PURGE or FRESHEN
// or No "external" matching file is found, or if found, but is too old or
// The external file is equal to the ziparchive name while ziparchive name
// != "-" If filetime() returns any valid time, then at least we know the
// file was found.
diag("checking new entries", pG);
// fileio.c built the found list
#ifdef USE_STRM_INPUT
if (!pG->UseInStream)
#endif
for (f = pG->found; f != NULL;)
{
int sz = 0;
if (pG->action == PURGE || pG->action == FRESHEN || (t = filetime(f->name,
(ulg*)NULL, &sz, (ztimbuf*)NULL, pG)) == 0
// || (t = filetime( f->name, ( ulg * )NULL, ( long * )NULL, ( ztimbuf * )NULL, pG )) == 0
|| t < pG->before || (namecmp(GetFullPath(pG, f->name), pG->zipfile) == 0
&& strcmp(pG->zipfile, "-")) || (sz < - 2))
{
if (sz < - 2)
Inform(pG, ZEN_SIZE04, IWARNING, "%s is too large", f->name);
if (pG->verbose && t < pG->before)
{
Inform(pG, 0, IDIAG, "rejecting %s as too early", f->name );
}
if (pG->verbose < 0)
Inform(pG, 0, IDIAG, "expel being called for %s", f->name);
f = fexpel(f, pG); // delete an entry in the list.
}
else
// file found, and not too old.
f = f->nxt;
// save this one, link it up.
}
if (pG->found == NULL)
diag("found list empty - a", pG);
else
diag("found list has at least one entry - a", pG);
if ( /* ( pG->action == UPDATE || pG->action == FRESHEN ) && */(pG->adjust <=
0))
pG->adjust = 0;
// Make sure there's something left to do RP adjust always 1
if (marks == 0 && pG->found == NULL && !(pG->zfiles != NULL && (pG->latest ||
pG->adjust || pG->junk_sfx)))
{
// FOUND WAS NULL HERE, so just figure out which error message to show
// the user
if (pG->action == UPDATE || pG->action == FRESHEN)
{
finish(pG);
Inform(pG, 0, IWARNING, "no files %s", (pG->action == UPDATE) ? "updated"
: "freshened");
return 0;
}
else if (pG->zfiles == NULL && (pG->latest || pG->adjust || pG->junk_sfx))
{
return (ziperr(ZEN_NAME01, pG));
}
else if (pG->recurse && (pG->pcount == 0) && (!pG->doall))
//first_listarg > 0) )
{
// add the list of filenames from cmd line to error msg
/// for ( i = first_listarg; i < argc; i++ )
/// lstrcat( lstrcat( pG->errbuf, " " ), argv[i] );
return (ziperr(ZEN_NONE01, pG));
}
else
return (ziperr(ZEN_NONE02, pG));
}
// AllowGrow is false if writing temporary file
pG->AllowGrow = (pG->AllowGrow && (marks == 0)
// is allowed and no changes to existing
&& (pG->zipbeg || pG->zfiles != NULL) // something to append to
);
// continue on to add new files
a = 0;
// ignore self-extracting code in front of the zip file (for -J)
if (pG->junk_sfx)
pG->zipbeg = 0;
// Count files and sizes which we have to Keep; RP Added
w = &pG->zfiles;
while ((z = *w) != NULL)
{
if (pG->global_abort_sw)
return (ziperr(ZEN_ABORT, pG));
if (!z->mark)
{
KeptSize += (z->siz + (ulg)(4+LOCHEAD) + (ulg)z->nam + (ulg)z->ext);
if (z->lflg &8)
KeptSize += 16;
KeptCnt++;
}
w = &z->nxt;
}
//Inform( pG, 0, IDIAG, "Kept = %u %Lu Total = %u %Lu", KeptCnt, KeptSize, TotFiles, TotSize );
// Count files and sizes which we have to process; RCV Added
// First the files in the old zip file...
// RP - already calculated with new sizes
// And the found list...
for (f = pG->found; f != NULL; f = f->nxt)
{
if (pG->global_abort_sw)
return (ziperr(ZEN_ABORT, pG));
TotSize += f->len;
TotFiles++;
}
// Inform( pG, 0, IDIAG, "Found = %u %u", tc, ts );
// OPEN ZIP FILE and temporary output file
// diag( "opening zip file and creating temporary zip file", pG );
pG->hInz = INVALID_HANDLE_VALUE; //0;
pG->hTempzf = INVALID_HANDLE_VALUE;
pG->tempzn = 0;
if (!pG->AllowGrow)
{
// check file exists
No_File = access(pG->zipfile, 0) && errno == ENOENT;
if (No_File && DestType == DRIVE_FIXED || DestType == DRIVE_RAMDISK)
{
// create file using given name
diag("in dllzip - ready to create new file", pG);
if ((pG->hOutz = CreateFile(pG->zipfile, GENERIC_WRITE, 0, NULL,
CREATE_NEW, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL)) !=
INVALID_HANDLE_VALUE)
{
pG->tempzip = pG->zipfile;
pG->hTempzf = pG->hOutz;
pG->AllowGrow = - 1; // new files do grow
}
}
}
if (pG->AllowGrow > 0)
{
// zipfile is not stdout, and we are allowed to append
// AllowGrow is true if we're just appending (-g)
diag("in dllzip - ready to open for appending", pG);
if ((pG->hOutz = CreateFile(pG->zipfile, GENERIC_READ | GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
NULL)) == INVALID_HANDLE_VALUE)
return (ziperr(ZEN_NAME02, pG));
pG->tempzip = pG->zipfile;
pG->hTempzf = pG->hOutz;
/* long */
hi = 0;
if (SetFilePointer(pG->hOutz, pG->cenbeg, &hi, FILE_BEGIN) ==
INVALID_SET_FILE_POINTER && GetLastError())
return (ziperr(GetLastError() ? ZEN_READ01 : ZEN_EOF01, pG));
pG->tempzn = pG->cenbeg;
}
if (!pG->AllowGrow)
{
diag("in dllzip - ready to open for Exclusive Read", pG);
if ((pG->zfiles != NULL || pG->zipbeg) && (pG->hInz = CreateFile(pG
->zipfile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL |
FILE_FLAG_SEQUENTIAL_SCAN, NULL)) == INVALID_HANDLE_VALUE)
return (ziperr(ZEN_NAME03, pG));
if ((pG->tempzip = tempname(pG)) == NULL)
return (ziperr(ZEN_MEM11, pG));
// if (pG->Verbose)
Inform(pG, 0, IDIAG, "Temp Filename = %s", pG->tempzip);
if ((pG->hTempzf = pG->hOutz = CreateFile(pG->tempzip, GENERIC_WRITE, 0,
NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS |
FILE_ATTRIBUTE_TEMPORARY, NULL)) == INVALID_HANDLE_VALUE)
return (ziperr(ZEN_TEMP01, pG));
}
if (!pG->AllowGrow)
{
TotFiles += KeptCnt;
TotSize += KeptSize;
}
// Pass total number of files and Total Filesize. (moved)
user_callback(zacCount, 0, TotFiles, NULL, pG);
user_callback(zacSize, (long)(TotSize >> 32), ((unsigned)TotSize), NULL, pG);
pG->BatchStarted = 1;
if (!pG->AllowGrow && pG->zipbeg)
{
// copy a compressed file from old archive to new archive
user_callback(zacItem, 0, pG->zipbeg, "SFX", pG);
if ((r = fcopy(pG->hInz, pG->hOutz, pG->zipbeg, pG)) != ZEN_OK)
return (ziperr(r, pG));
pG->tempzn = pG->zipbeg;
}
// o = 0; /* no ZEN_OPEN errors yet
// Process zip file, copying from old archive to new archive. Rezip any
// marked files
if (pG->zfiles != NULL)
diag("going through old zip file", pG);
w = &pG->zfiles;
while ((z = *w) != NULL)
{
if (pG->global_abort_sw)
{
return (ziperr(ZEN_ABORT, pG));
}
if (z->mark == 1)
{
// This file is marked
// if not deleting, rezip it
if (pG->action != PURGE)
{
Inform(pG, 0, 0, "updating: %s", Oem2Iso(z->zname, pG));
// zipup is in file zipup.c
if ((r = zipup(z, pG->hOutz, pG)) != ZEN_OK && (int)(char)(r &0xFF) !=
ZEN_OPEN && (int)(char)(r &0xFF) != ZEN_MISS)
{
return (ziperr(r, pG));
}
if ((int)(char)(r &0xFF) == ZEN_OPEN || (int)(char)(r &0xFF) ==
ZEN_MISS)
{
if ((int)(char)(r &0xFF) == ZEN_OPEN)
{
Inform(pG, r, IWARNING, "could not open for reading: %s", z->name);
user_callback(4, r, 0, z->name, pG);
}
else
{
Inform(pG, 0, IWARNING, "file and directory with the same name: %s",
z->name);
user_callback(4, r, 0, z->name, pG);
}
Inform(pG, 0, IWARNING, "will just copy entry over: %s", z->zname);
if ((r = zipcopy(z, pG->hInz, pG->hOutz, pG)) != ZEN_OK)
{
sprintf(pG->errbuf, "was copying %s", z->zname);
return (ziperr(r, pG));
}
z->mark = 0;
}
w = &z->nxt;
pG->files_acted_on++;
}
else
{
// desired action is DELETE, this file marked
// NOTE: no progress bar supt for DELETE yet
Inform(pG, 0, 0, "deleting: %s", Oem2Iso(z->zname, pG));
v = z->nxt; // delete entry from list
FREE(z->name);
FREE(z->zname);
if (z->ext)
FREE(z->extra);
if (z->cext && z->cextra != z->extra)
FREE(z->cextra);
if (z->com)
FREE(z->comment);
FREE(z);
*w = v;
pG->zcount--;
pG->files_acted_on++;
}
}
else
{
// this file wasn't marked
// copy the original entry verbatim
if (!pG->AllowGrow)
{
Inform(pG, 0, 0, "keeping: %s", Oem2Iso(z->zname, pG));
if ((r = zipcopy(z, pG->hInz, pG->hOutz, pG)) != ZEN_OK)
{
sprintf(pG->errbuf, "was copying %s", z->zname);
// user_callback ( zacEndOfBatch, 0, 0, NULL, pG ); // done with a
// batch of files
return (ziperr(r, pG));
}
}
w = &z->nxt;
}
} // end while
// Process the "found" list, adding them to the zip file.
// This is used to add files that weren't already in the archive.
if (pG->verbose)
{
Inform(pG, 0, IDIAG, "Zipping up %d NEW entries from found list", pG
->fcount);
}
// For each new file to add (src names in found list), make a new entry
// for it in the "zfiles" linked list, zip up the new file, then remove the
// entry from the found list.
// The last item in the for loop control deallocates spc for fname that
// was just zipped up
for (f = pG->found; f != NULL; f = fexpel(f, pG))
{
// add a new entry to "zfiles" list, before we zip up the file. That way
// we'll be ready to update the ZIP file's directory later.
if (pG->global_abort_sw)
{
// user_callback ( zacEndOfBatch, 0, 0, NULL, pG ); // done with a
// batch of files
return (ziperr(ZEN_ABORT, pG));
}
if ((z = (struct zlist*)MALLOC(sizeof(struct zlist))) == NULL)
{
return (ziperr(ZEN_MEM12, pG));
}
// RP 1.73 clear all fields
memset(z, 0, sizeof(struct zlist));
// Similar names below are confusing: f->name f->zname z->name z->zname
// z z->nxt = NULL;
z->name = f->name;
f->name = NULL;
z->zname = f->zname;
f->zname = NULL;
// z z->ext = z->cext = z->com = 0;
// z z->extra = z->cextra = z->comment = NULL;
// pRP173 z->ext = strlen( f->passw ); //Added RAEL
// pRP173 z->extra = f->passw; //Added RAEL for per file password
z->passw = f->passw; // p
f->passw = NULL; // Added RAEL
z->mark = 1;
z->dosflag = f->dosflag;
z->len = f->len; // RCV added.
// zip it up
Inform(pG, 0, 0, " adding: %s", Oem2Iso(z->zname, pG));
// This is it - try to zip up new file
if ((r = zipup(z, pG->hOutz, pG)) != ZEN_OK && (int)(char)(r &0xFF) !=
ZEN_OPEN && (int)(char)(r &0xFF) != ZEN_MISS)
{
return (ziperr(r, pG));
}
if ((int)(char)(r &0xFF) == ZEN_OPEN || (int)(char)(r &0xFF) == ZEN_MISS)
{
// o = 1;
if ((int)(char)(r &0xFF) == ZEN_OPEN)
{
Inform(pG, r, IWARNING, "could not open for reading: %s", z->name);
}
else
{
Inform(pG, 0, IWARNING, "file and directory with the same name: %s", z
->name);
}
FREE(z->name);
FREE(z->zname);
FREE(z);
}
else
{
// "zipup" of this file was good
*w = z;
w = &z->nxt;
pG->zcount++;
pG->files_acted_on++;
}
}
// Write central directory and end header to temporary zip
diag("writing central directory", pG);
hi = 0;
ofs = SetFilePointer(pG->hOutz, 0, &hi, FILE_CURRENT);
if (hi || (ofs > 0xFFFFFFF0u) || (ofs == INVALID_SET_FILE_POINTER &&
GetLastError()))
{
return ziperr(ZEN_SIZE01, pG);
}
k = 0; // keep count of new fnames for ZIPfile's end header
c = pG->tempzn; // get start of central directory
n = t = 0;
altered = 0; // RP 173 - count changes
for (z = pG->zfiles; z != NULL; z = z->nxt)
{
// Handle callback and result for the filecomments... DLL v1.609,
// Component v1.60L
if (pG->action != PURGE)
{
memset(pG->ewetmp, 0, 513); // Clear all
strncpy(pG->ewetmp, z->zname, 255); // Copy external filename
if (z->com)
// Copy old comment if present
strncpy(pG->ewetmp + 256, z->comment, min(z->com, 255));
else
z->comment = 0;
user_callback(12, 0, z->com, pG->ewetmp, pG);
if (pG->callbackdata.error_code)
{
// User changed the comment
FREE(z->comment);
z->com = pG->callbackdata.fsize;
if ((z->comment = (char*)MALLOC(z->com + 1)) == NULL)
return (ziperr(ZEN_MEM37, pG));
strncpy(z->comment, pG->callbackdata.filenameormsg, z->com + 1);
altered++;
}
}
if (pG->files_acted_on < altered)
// RP 173 - comments changed is acted on
pG->files_acted_on = altered;
if ((r = putcentral(z, pG->hOutz, pG)) != ZEN_OK)
{
// v1.6014
return (ziperr(r, pG));
}
pG->tempzn += 4+CENHEAD + z->nam + z->cext + z->com;
n += z->len;
t += z->siz;
k++;
}
if (k == 0)
Inform(pG, 0, IWARNING, "zip file empty");
if ((pG->verbose) && (pG->action == ADD) && (!pG->global_error_code) && (pG
->files_acted_on > 0))
{
Inform(pG, 0, 0, "Total Bytes=%lu, compr bytes=%lu -> %d%% savings", n, t,
percent(n, t));
}
t = pG->tempzn - c; // compute length of central
diag("writing end of central directory", pG);
if (k && ((r = putend(k, t, c, pG->hOutz, pG)) != ZEN_OK))
{
return (ziperr(r, pG));
}
// if ( pG->hInz != INVALID_HANDLE_VALUE )
// {
Close_Handle(&pG->hInz);
// pG->hInz = INVALID_HANDLE_VALUE;
// }
// pG->tempzf = NULL;
// if ( fclose ( pG->y ) )
pG->hTempzf = INVALID_HANDLE_VALUE; //NULL;
// if ( pG->hOutz != INVALID_HANDLE_VALUE && !CloseHandle( pG->hOutz ) )
if (!Close_Handle(&pG->hOutz))
{
return (ziperr(pG->AllowGrow ? ZEN_WRITE03 : ZEN_TEMP02, pG));
}
// pG->hOutz = INVALID_HANDLE_VALUE;
#ifdef DYN_ALLOC
lm_free(pG);
#endif
// if ( pG->verbose )
// Inform( pG, 0, IDIAG, "Files closed in: %X out: %x", pG->hInz, pG->hOutz );
// Replace old zip file with new zip file, leaving only the new one
// if ( !pG->AllowGrow ) // && lstrcmp(pG->zipfile, pG->tempzip))
if (!pG->AllowGrow && (k || pG->action != PURGE))
// && lstrcmp(pG->zipfile, pG->tempzip))
{
diag("replacing old zip file with new zip file", pG);
if ((r = replace(pG->zipfile, pG->tempzip, pG)) != ZEN_OK)
{
Inform(pG, 0, IWARNING, "new zip file left as: %s", pG->tempzip);
FREE(pG->tempzip);
pG->tempzip = NULL;
return (ziperr(r, pG));
}
FREE(pG->tempzip);
pG->tempzip = NULL;
}
// 1.78.1.2
if (!k && pG->action == PURGE)
// empty file - remove
{
a = pG->latest = 0;
DeleteFile(pG->zipfile);
if (!pG->AllowGrow)
DeleteFile(pG->tempzip);
}
pG->tempzip = NULL;
if (a)
setfileattr(pG->zipfile, a);
// Reset the archive bit when needed for all successfull zipped files
if (pG->ResetArchiveBit && pG->action != PURGE)
{
unsigned cnt = 0; // 1.71.0.0 added extra callbacks
diag("resetting archive bits", pG);
for (z = pG->zfiles; z != NULL; z = z->nxt)
if (z->mark)
cnt++;
if (cnt)
{
// new file op.
// Pass total number of files. filesize.
user_callback(zacXItem, 1, cnt, "*resetting archive bits", pG);
}
cnt = 0;
for (z = pG->zfiles; z != NULL; z = z->nxt)
{
if (z->mark)
{
char *fullname;
if (++cnt == 30)
{
user_callback(zacXProgress, 1, cnt, "", pG);
cnt = 0;
if (pG->global_abort_sw)
break;
}
fullname = GetFullPath(pG, z->name); // v.16017
if (!SetFileAttributes(fullname, GetFileAttributes(fullname)
&~FILE_ATTRIBUTE_ARCHIVE))
{
Inform(pG, 0, IWARNING, "Archive bit could not be set for: %s", z
->name);
}
}
}
if (cnt)
{
user_callback(zacXProgress, 1, cnt, "", pG); // last few
}
}
finish(pG);
return 0;
}
int main(
int argc,
char *argv[])
{
int i;
int opt_overwrite=0;
int opt_compress_level=Z_DEFAULT_COMPRESSION;
int opt_exclude_path=0;
int zipfilenamearg = 0;
char filename_try[MAXFILENAME+16];
int zipok;
int err=0;
int size_buf=0;
void* buf=NULL;
const char* password=NULL;
do_banner();
if (argc==1)
{
do_help();
return 0;
}
else
{
for (i=1;i<argc;i++)
{
if ((*argv[i])=='-')
{
const char *p=argv[i]+1;
while ((*p)!='\0')
{
char c=*(p++);;
if ((c=='o') || (c=='O'))
opt_overwrite = 1;
if ((c=='a') || (c=='A'))
opt_overwrite = 2;
if ((c>='0') && (c<='9'))
opt_compress_level = c-'0';
if ((c=='j') || (c=='J'))
opt_exclude_path = 1;
if (((c=='p') || (c=='P')) && (i+1<argc))
{
password=argv[i+1];
i++;
}
}
}
else
{
if (zipfilenamearg == 0)
{
zipfilenamearg = i ;
}
}
}
}
size_buf = WRITEBUFFERSIZE;
buf = (void*)malloc(size_buf);
if (buf==NULL)
{
printf("Error allocating memory\n");
return ZIP_INTERNALERROR;
}
if (zipfilenamearg==0)
{
zipok=0;
}
else
{
int i,len;
int dot_found=0;
zipok = 1 ;
strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
/* strncpy doesnt append the trailing NULL, of the string is too long. */
filename_try[ MAXFILENAME ] = '\0';
len=(int)strlen(filename_try);
for (i=0;i<len;i++)
if (filename_try[i]=='.')
dot_found=1;
if (dot_found==0)
strcat(filename_try,".zip");
if (opt_overwrite==2)
{
/* if the file don't exist, we not append file */
if (check_exist_file(filename_try)==0)
opt_overwrite=1;
}
else
if (opt_overwrite==0)
if (check_exist_file(filename_try)!=0)
{
char rep=0;
do
{
char answer[128];
int ret;
printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
ret = scanf("%1s",answer);
if (ret != 1)
{
exit(EXIT_FAILURE);
}
rep = answer[0] ;
if ((rep>='a') && (rep<='z'))
rep -= 0x20;
}
while ((rep!='Y') && (rep!='N') && (rep!='A'));
if (rep=='N')
zipok = 0;
if (rep=='A')
opt_overwrite = 2;
}
}
if (zipok==1)
{
zipFile zf;
int errclose;
# ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
fill_win32_filefunc64A(&ffunc);
zf = zipOpen2_64(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
# else
zf = zipOpen64(filename_try,(opt_overwrite==2) ? 2 : 0);
# endif
if (zf == NULL)
{
printf("error opening %s\n",filename_try);
err= ZIP_ERRNO;
}
else
printf("creating %s\n",filename_try);
for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
{
if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
((argv[i][1]=='o') || (argv[i][1]=='O') ||
(argv[i][1]=='a') || (argv[i][1]=='A') ||
(argv[i][1]=='p') || (argv[i][1]=='P') ||
((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
(strlen(argv[i]) == 2)))
{
FILE * fin;
int size_read;
const char* filenameinzip = argv[i];
const char *savefilenameinzip;
zip_fileinfo zi;
unsigned long crcFile=0;
int zip64 = 0;
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
zi.dosDate = 0;
zi.internal_fa = 0;
zi.external_fa = 0;
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
/*
err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
NULL,0,NULL,0,NULL / * comment * /,
(opt_compress_level != 0) ? Z_DEFLATED : 0,
opt_compress_level);
*/
if ((password != NULL) && (err==ZIP_OK))
err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
zip64 = isLargeFile(filenameinzip);
/* The path name saved, should not include a leading slash. */
/*if it did, windows/xp and dynazip couldn't read the zip file. */
savefilenameinzip = filenameinzip;
while( savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/' )
{
savefilenameinzip++;
}
/*should the zip file contain any path at all?*/
if( opt_exclude_path )
{
const char *tmpptr;
const char *lastslash = 0;
for( tmpptr = savefilenameinzip; *tmpptr; tmpptr++)
{
if( *tmpptr == '\\' || *tmpptr == '/')
{
lastslash = tmpptr;
}
}
if( lastslash != NULL )
{
savefilenameinzip = lastslash+1; // base filename follows last slash.
}
}
/**/
err = zipOpenNewFileInZip3_64(zf,savefilenameinzip,&zi,
NULL,0,NULL,0,NULL /* comment*/,
(opt_compress_level != 0) ? Z_DEFLATED : 0,
opt_compress_level,0,
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
password,crcFile, zip64);
if (err != ZIP_OK)
printf("error in opening %s in zipfile\n",filenameinzip);
else
{
fin = FOPEN_FUNC(filenameinzip,"rb");
if (fin==NULL)
{
err=ZIP_ERRNO;
printf("error in opening %s for reading\n",filenameinzip);
}
}
if (err == ZIP_OK)
do
{
err = ZIP_OK;
size_read = (int)fread(buf,1,size_buf,fin);
if (size_read < size_buf)
if (feof(fin)==0)
{
printf("error in reading %s\n",filenameinzip);
err = ZIP_ERRNO;
}
if (size_read>0)
{
err = zipWriteInFileInZip (zf,buf,size_read);
if (err<0)
{
printf("error in writing %s in the zipfile\n",
filenameinzip);
}
}
} while ((err == ZIP_OK) && (size_read>0));
if (fin)
fclose(fin);
if (err<0)
err=ZIP_ERRNO;
else
{
err = zipCloseFileInZip(zf);
if (err!=ZIP_OK)
printf("error in closing %s in the zipfile\n",
filenameinzip);
}
}
}
errclose = zipClose(zf,NULL);
if (errclose != ZIP_OK)
printf("error in closing %s\n",filename_try);
}
else
{
do_help();
}
free(buf);
return 0;
}
