int vbe_get_mode_info(unsigned short mode, vbe_mode_info_t *vmi_p)
{
mmap_t map;
if (lm_alloc(sizeof(vbe_mode_info_t), &map) == NULL)
{
return 1;
}
struct reg86u reg86;
reg86.u.b.intno = VBE_INTERRUPT_VECTOR; /* BIOS video services */
reg86.u.b.ah = VBE_FUNCTION;
reg86.u.b.al = VBE_RETURN_VBE_MODE_INFO;
reg86.u.w.cx = mode;
reg86.u.w.es = PB2BASE(map.phys);
reg86.u.w.di = PB2OFF(map.phys);
if (sys_int86(®86) == OK)
{
if (reg86.u.w.ax == VBE_FUNCTION_SUPPORTED | VBE_FUNCTION_CALL_SUCCESSFUL)
{
*vmi_p = *((vbe_mode_info_t *)map.virtual);
lm_free(&map);
return 0;
}
}
static PGPError
Teardown (PGPPipeline *myself)
{
DefModContext *context;
PGPContextRef cdkContext;
pgpAssertAddrValid( myself, PGPPipeline );
cdkContext = myself->cdkContext;
pgpAssert (myself);
pgpAssert (myself->magic == DEFMODMAGIC);
context = (DefModContext *)myself->priv;
pgpAssert (context);
if (context->tail)
context->tail->teardown (context->tail);
bi_free (context->zbcontext); /* Free bits data structures */
ct_free (context->ztcontext); /* Free code tree buffers */
lm_free (context->zdcontext); /* Free longest match buffers */
byteFifoDestroy (context->fifo);
pgpClearMemory( context, sizeof (*context));
pgpContextMemFree( cdkContext, context);
return kPGPError_NoErr;
}
int vbe_get_mode_info(unsigned short mode, vbe_mode_info_t *vmi_p) {
struct reg86u reg86;
mmap_t memory;
lm_init();
lm_alloc(VBE_MODE_INFO_SIZE, &memory);
reg86.u.w.ax = 0x4F01;
reg86.u.w.cx = 1 << 14 | mode;
reg86.u.w.es = PB2BASE(memory.phys);
reg86.u.w.di = PB2OFF(memory.phys);
reg86.u.b.intno = 0x10;
if(sys_int86(®86) != OK){
printf("vbe_get_mode_info: sys_int86() failed \n");
return 1;
}
memcpy(vmi_p, memory.virtual, VBE_MODE_INFO_SIZE);
lm_free(&memory);
return 0;
}
void
lmset_free(lmset_t * lms)
{
int i;
for (i = 0; i < lms->n_lm; i++) {
ckd_free((void *) lms->lmarray[i]->name);
lms->lmarray[i]->name = NULL;
lm_free(lms->lmarray[i]);
}
ckd_free(lms->lmarray);
ckd_free((void *) lms);
}
int controler_info(){
mmap_t map_info;
char * virtualBase = (char *) lm_init();
if(virtualBase == NULL) return 1;
VESA_INFO *info = (VESA_INFO *)lm_alloc(sizeof(VESA_INFO), &map_info);
info->VESASignature[0] = 'V';
info->VESASignature[1] = 'B';
info->VESASignature[2] = 'E';
info->VESASignature[3] = '2';
vbe_get_controler_info(map_info.phys);
char* ptr;
ptr = REALPTR(info->VideoModePtr) + virtualBase;
unsigned short *videoModesPtr = (unsigned short *)ptr;
printf("Capabilites: \n");
if(info->Capabilities[0] & BIT(0)){
printf("DAC width is switchable to 8 bits per primary color\n");
}
else{
printf("DAC is fixed width, with 6 bits per primary color\n");
}
if(info->Capabilities[0] & BIT(1)){
printf("Controller is not VGA compatible\n");
}
else{
printf("Controller is VGA compatible\n");
}
if(info->Capabilities[0] & BIT(2)){
printf("When programming large blocks of information to the RAMDAC, use the blank bit in Function 09h.\n");
}
else{
printf("Normal RAMDAC operation\n");
}
printf("\n Modes: \n");
while(*videoModesPtr != END){
printf("0x%X \t", *videoModesPtr);
videoModesPtr++;
}
printf("\n\n VRAM SIZE: %d blocks of 64 KB\n", info->TotalMemory);
lm_free(&map_info);
return 0;
}
int vbe_get_mode_info(unsigned short mode, vbe_mode_info_t *vmi_p) {
struct reg86u registers;
mmap_t address;
lm_init();
lm_alloc(VBE_MODE_INFO_BLOCK_SIZE, &address);
registers.u.b.ah = 0x4F;
registers.u.b.al = 0x01;
registers.u.w.es = PB2BASE(address.phys);
registers.u.w.di = PB2OFF(address.phys);
registers.u.b.intno = 0x10;
registers.u.w.cx = 1 << 14 | mode;
sys_int86(®isters);
vbe_unpack_mode_info(address.virtual, vmi_p);
lm_free(&address);
return 1;
}
int
main(int argc, char *argv[])
{
const char *inputfn;
const char *outputfn;
char *local_outputfn;
const char *inputfmt;
const char *outputfmt;
const char *inputenc;
const char *outputenc;
const char *outputdir;
char *outputpath;
int outputfnfree = FALSE;
lm_t *lm;
char separator[2];
cmd_ln_t *config;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", arg);
config = cmd_ln_get();
inputfn = NULL;
outputfn = local_outputfn = NULL;
inputfmt = NULL;
outputfmt = NULL;
outputdir = NULL;
inputfn = cmd_ln_str_r(config, "-i");
outputfn = cmd_ln_str_r(config, "-o");
inputfmt = cmd_ln_str_r(config, "-ifmt");
outputfmt = cmd_ln_str_r(config, "-ofmt");
inputenc = cmd_ln_str_r(config, "-ienc");
outputenc = cmd_ln_str_r(config, "-oenc");
outputdir = cmd_ln_str_r(config, "-odir");
if (!strcmp(inputfmt, outputfmt) && !strcmp(inputenc, outputenc))
E_FATAL
("Input and Output file formats and encodings are the same (%s, %s). Do nothing\n",
inputfmt, inputenc);
if (!encoding_resolve
(cmd_ln_str_r(config, "-ienc"), cmd_ln_str_r(config, "-oenc")))
E_FATAL
("Input and output encoding types is either not compatible or the conversion is not supported. Forced exit\n");
/* Read LM */
if ((lm =
lm_read_advance2(inputfn, "default", 1.0, 0.1, 1.0, 0, inputfmt,
0, 1, NULL, FALSE, FALSE)) == NULL)
E_FATAL("Fail to read inputfn %s in inputfmt %s\n", inputfn,
inputfmt);
if (outputfn == NULL) {
/* Length = strlen(inputfn) + 1 + strlen(outputfmt) + 5 (For safety) */
outputfn = local_outputfn = (char *) ckd_calloc(strlen(inputfn) + strlen(outputfmt) + 5, sizeof(char));
sprintf(local_outputfn, "%s.%s", inputfn, outputfmt);
outputfnfree = TRUE;
}
/* Outputpath = outputdir . "/" (or "\" in windows). outputfn; */
/* Length = strlen(outputdir) + 1 + strlen(outputfn) + 5 (For safety) */
outputpath =
(char *) ckd_calloc(strlen(outputdir) + strlen(outputfn) + 6, sizeof(char));
#if WIN32
strcpy(separator, "\\");
#else
strcpy(separator, "/");
#endif
sprintf(outputpath, "%s%s%s", outputdir, separator, outputfn);
lm_write(lm, outputpath, inputfn, outputfmt);
if (local_outputfn) {
ckd_free(local_outputfn);
}
ckd_free(outputpath);
lm_free(lm);
cmd_ln_free_r(config);
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;
}