[wxWidgets.git] / utils / Install / sfxace / unace.c

/* ------------------------------------------------------------------------ */
/*                                                                          */
/*      Main file of public UNACE.                                          */
/*                                                                          */
/* ------------------------------------------------------------------------ */


#define INCL_WIN       /* Window Manager Functions     */
#define INCL_DOS
#define INCL_BASE


//--------------- include general files ------------------------------------//
#include <ctype.h>      // tolower()
#include <fcntl.h>      // open()
#include <stdio.h>      // printf() sprintf() remove()
#include <stdlib.h>     // malloc()
#include <string.h>     // str*()
#include <sys/types.h>
#include <sys/stat.h>   // S_I*  AMIGA: fstat()
#if (!defined(__EMX__) && !defined(__OS2__) && !defined(WINNT) && !defined(WIN32)) ||  defined(__CYGWIN__)
#include <sys/errno.h>
#endif

#if !defined(__EMX__) && !defined(__OS2__) && !defined(WIN32) && !defined(WINNT)
#define stricmp strcasecmp
#endif

#include "install.h"
#include "instsup.h"
extern int installstate;

off_t acelseek(off_t offset, int whence);
int aceread(void *buf, size_t count);
int aceopen(const char *path, int flags);
int aceclose(int fd);
int acesize(void);
int acetell(int fd);
char *replacestr(char *str1, char *str2, char *str3);

//--------------- include unace specific header files ----------------------//
#include "os.h"

#include "globals.h"
#include "portable.h"
#include "uac_comm.h"
#include "uac_crc.h"
#include "uac_crt.h"
#include "uac_dcpr.h"
#include "uac_sys.h"

#ifdef CRYPT
 #include "unace_ps.h"
#endif /* CRYPT */


//--------------- BEGIN OF UNACE ROUTINES ----------------------------------//

int pipeit(char *format, ...)
{
	/* Do nothing ... perhaps pipe this somewhere in the future */
	return 0;
} 

void init_unace(void)           // initializes unace
{
	buf_rd =malloc(size_rdb * sizeof(ULONG));  // Allocate buffers: increase
	buf    =malloc(size_buf);                  // sizes when possible to speed
	buf_wr =malloc(size_wrb);                  // up the program
	readbuf=malloc(size_headrdb);

	if (buf_rd ==NULL ||
		buf    ==NULL ||
		buf_wr ==NULL ||
		readbuf==NULL )
		f_err = ERR_MEM;

	make_crctable();             // initialize CRC table
	dcpr_init();                 // initialize decompression

	set_handler();               // ctrl+break etc.
}

void done_unace(void)
{
	if (buf_rd   ) free(buf_rd   );
	if (buf      ) free(buf      );
	if (buf_wr   ) free(buf_wr   );
	if (readbuf  ) free(readbuf  );
	if (dcpr_text) free(dcpr_text);
}

INT  read_header(INT print_err)         // reads any header from archive
{
	USHORT rd,
	head_size,
	crc_ok;
	LONG crc;
	UCHAR *tp=readbuf;

	acelseek(skipsize, SEEK_CUR);   // skip ADDSIZE block

	if (aceread(&head, 4)<4)
		return (0);                       // read CRC and header size

#ifdef HI_LO_BYTE_ORDER
	WORDswap(&head.HEAD_CRC);
	WORDswap(&head.HEAD_SIZE);
#endif
	// read size_headrdb bytes into
	head_size = head.HEAD_SIZE;          // header structure
	rd = (head_size > size_headrdb) ? size_headrdb : head_size;
	if (aceread(readbuf, rd) < rd)
		return (0);
	head_size -= rd;
	crc = getcrc(CRC_MASK, readbuf, rd);

	while (head_size)                    // skip rest of header
	{
		rd = (head_size > size_buf) ? size_buf : head_size;
		if (aceread(buf, rd) < rd)
			return (0);
		head_size -= rd;
		crc = getcrc(crc, (UCHAR*)buf, rd);
	}

	head.HEAD_TYPE =*tp++;               // generic buffer to head conversion
	head.HEAD_FLAGS=BUFP2WORD(tp);

	if (head.HEAD_FLAGS & ACE_ADDSIZE)
		skipsize = head.ADDSIZE = BUF2LONG(tp);   // get ADDSIZE
	else
		skipsize = 0;

	// check header CRC
	if (!(crc_ok = head.HEAD_CRC == (crc & 0xffff)) && print_err)
		pipeit("\nError: archive is broken\n");
	else
		switch (head.HEAD_TYPE)              // specific buffer to head conversion
		{
		case MAIN_BLK:
			memcpy(mhead.ACESIGN, tp, acesign_len); tp+=acesign_len;
			mhead.VER_MOD=*tp++;
			mhead.VER_CR =*tp++;
			mhead.HOST_CR=*tp++;
			mhead.VOL_NUM=*tp++;
			mhead.TIME_CR=BUFP2LONG(tp);
			mhead.RES1   =BUFP2WORD(tp);
			mhead.RES2   =BUFP2WORD(tp);
			mhead.RES    =BUFP2LONG(tp);
			mhead.AV_SIZE=*tp++;
			memcpy(mhead.AV, tp, rd-(USHORT)(tp-readbuf));
			break;
		case FILE_BLK:
			fhead.PSIZE     =BUFP2LONG(tp);
			fhead.SIZE      =BUFP2LONG(tp);
			fhead.FTIME     =BUFP2LONG(tp);
			fhead.ATTR      =BUFP2LONG(tp);
			fhead.CRC32     =BUFP2LONG(tp);
			fhead.TECH.TYPE =*tp++;
			fhead.TECH.QUAL =*tp++;
			fhead.TECH.PARM =BUFP2WORD(tp);
			fhead.RESERVED  =BUFP2WORD(tp);
			fhead.FNAME_SIZE=BUFP2WORD(tp);
			memcpy(fhead.FNAME, tp, rd-(USHORT)(tp-readbuf));
			break;
			//    default: (REC_BLK and future things):
			//              do nothing 'cause isn't needed for extraction
		}

	return (crc_ok);
}
// maximum SFX module size
#define max_sfx_size 65536      // (needed by read_arc_head)

INT read_arc_head(void)         // searches for the archive header and reads it
{
	INT  i,
	flags,
	buf_pos = 0;
	LONG arc_head_pos,
		old_fpos,
	fpos = 0;
	struct stat st;

	fstat(archan, &st);

	memset(buf, 0, size_buf);

	while (acetell(archan)<acesize() && fpos < max_sfx_size)
	{
		old_fpos = fpos;
		fpos += aceread(&buf[buf_pos], size_buf - buf_pos);

		for (i = 0; i < size_buf; i++)    // look for the acesign
		{
			if (!memcmp(acesign, &buf[i], acesign_len))
			{
				// seek to the probable begin
				// of the archive
				arc_head_pos = old_fpos + i - buf_pos -  bytes_before_acesign;
				acelseek(arc_head_pos, SEEK_SET);
				if (read_header(0))         // try to read archive header
				{
					flags = mhead.HEAD_FLAGS;
					adat.sol     = (flags & ACE_SOLID) > 0;
					adat.vol     = (flags & ACE_MULT_VOL) > 0;
					adat.vol_num = mhead.VOL_NUM;
					adat.time_cr = mhead.TIME_CR;
					return (1);
				}
			}
		}
		// was no archive header,
		// continue search
		acelseek(fpos, SEEK_SET);
		memcpy(buf, &buf[size_buf - 512], 512);
		buf_pos = 512;                    // keep 512 old bytes
	}
	return (0);
}

INT  open_archive(INT print_err)        // opens archive (or volume)
{
	CHAR av_str[80];

#if defined(__OS2_) || defined(__EMX__) || defined(WIN32)
	archan = aceopen(aname, O_RDONLY | O_BINARY);   // open file
#else
	archan = aceopen(aname, O_RDONLY);   // open file
#endif
#if !defined(__EMX__) && !defined(__OS2__)
	farchan = fdopen(archan, "rb");
#endif

	if (archan == -1)
	{
		error("\nError opening file %s", aname);
		return (0);
	}
	if (!read_arc_head())                        // read archive header
	{
		error("Invalid embedded archive file.");
#if !defined(__EMX__) && !defined(__OS2__)
		fclose(farchan);
#endif
		aceclose(archan);
		return (0);
	}

	pipeit("\nProcessing archive: %s\n\n", aname);
	if (head.HEAD_FLAGS & ACE_AV)
	{
		pipeit("Authenticity Verification:");   // print the AV
		sprintf(av_str, "\ncreated on %d.%d.%d by ",
				ts_day(adat.time_cr), ts_month(adat.time_cr), ts_year(adat.time_cr));
		pipeit(av_str);
		strncpy(av_str, (CHAR*)mhead.AV, mhead.AV_SIZE);
		av_str[mhead.AV_SIZE] = 0;
		pipeit("%s\n\n", av_str);
	}
	comment_out("Main comment:");        // print main comment
	return (1);
}

void get_next_volname(void)             // get file name of next volume
{
	CHAR *cp;
	INT  num;

	if ((cp = (CHAR *) strrchr(aname, '.')) == NULL || !*(cp + 1))
		num = -1;
	else
	{
		cp++;
		num = (*(cp + 1) - '0') * 10 + *(cp + 2) - '0';
		if (!in(num, 0, 99))
			num = -1;
		if (in(*cp, '0', '9'))
			num += (*cp - '0') * 100;
	}
	num++;

	if (num < 100)
		*cp = 'C';
	else
		*cp = num / 100 + '0';
	*(cp + 1) = (num / 10) % 10 + '0';
	*(cp + 2) = num % 10 + '0';
}

INT  proc_vol(void)                     // opens volume
{
	INT  i;
	CHAR s[80];

	if (!fileexists(aname) || !f_allvol_pr)
	{
		do
		{
			sprintf(s, "Ready to process %s?", aname);
#if defined(__MINGW32__)
			beep(500,500);
#else
			beep();
#endif
			i = confirm(s);                  // ask whether ready or not
			f_allvol_pr = (i == 1);        // "Always" --> process all volumes
			if (i >= 2)
			{
				f_err = ERR_FOUND;
				return (0);
			}
		}
		while (!fileexists(aname));
	}

	if (!open_archive(1))                // open volume
	{
		pipeit("\nError while opening archive. File not found or archive broken.\n");
		f_err = ERR_OPEN;
		return (0);
	}

	return (1);
}

INT  proc_next_vol(void)        // opens next volume to process
{
#if !defined(__EMX__) && !defined(__OS2__)
	fclose(farchan);
#endif
	aceclose(archan);               // close handle
	get_next_volname();          // get file name of next volume

	if (!proc_vol())             // try to open volume, read archive header
		return 0;
	if (!read_header(1))         // read 2nd header
	{
		f_err=ERR_READ;
		return 0;
	}
	return 1;
}

INT  read_adds_blk(CHAR * buffer, INT len)      // reads part of ADD_SIZE block
{
	INT  rd = 0,
	l = len;
	LONG i;

#ifdef CRYPT
	char *cbuffer=buffer;

	if (head.HEAD_TYPE == FILE_BLK && (head.HEAD_FLAGS & ACE_PASSW))
		len = crypt_len(len);
#endif /* CRYPT */
	while (!f_err && len && skipsize)
	{
		i = (skipsize > len) ? len : skipsize;
		skipsize -= i;

		/* How do I test failure when compiling -mno-cygwin? */
#if !defined(__MINGW32__)
		errno = 0;
#endif
		rd += aceread(buffer, i);
#if !defined(__MINGW32__)
		if (errno)
		{
			error("\nRead error\n");
			f_err = ERR_READ;
		}
#endif

		buffer += i;
		len -= i;

		if (!skipsize)            // if block is continued on next volume
			if (head.HEAD_FLAGS & ACE_SP_AFTER && !proc_next_vol())
				break;
	}
#ifdef CRYPT
	if (head.HEAD_TYPE == FILE_BLK && (head.HEAD_FLAGS & ACE_PASSW))
		decrypt(cbuffer, rd);
#endif /* CRYPT */

	return (rd > l ? l : rd);
}

void crc_print(void)            // checks CRC, prints message
{
	INT  crc_not_ok = rd_crc != fhead.CRC32;  /* check CRC of file */

	if(crc_not_ok && installstate != ABORTED)
		error("CRC error reading archive!");
}

void analyze_file(void)         // analyzes one file (for solid archives)
{
	pipeit("\n Analyzing");
	flush;
	while (!cancel() && (dcpr_adds_blk(buf_wr, size_wrb))) // decompress only
		;
	crc_print();
}

void extract_file(void)         // extracts one file
{
	INT  rd;

	pipeit("\n Extracting");
	flush;                       // decompress block
	while (!cancel() && (rd = dcpr_adds_blk(buf_wr, size_wrb)))
	{
		if (write(wrhan, buf_wr, rd) != rd)       // write block
		{
			error("\nWrite error\n");
			f_err = ERR_WRITE;
		}
	}
	crc_print();
}


/* extracts or tests all files of the archive
 */
void extract_files(int nopath, int test, char *getfilename)
{
	CHAR file[PATH_MAX];
	char *tmpfile;
	extern unsigned current_file;
	extern char installdir2[];

	while (!cancel() && read_header(1))
	{
		if (head.HEAD_TYPE == FILE_BLK)
		{
			if(installstate == ABORTED)
				return;
			current_file++;
			if(installstate == INSTALLING)
				DoGUI();

			comment_out("File comment:");   // show file comment
			ace_fname(file, &head, nopath); // get file name

			/* We allow expansion of "userdir" to the selected directory by the user */
			tmpfile = replacestr(file, "USERDIR", installdir2);
			strcpy(file, tmpfile);
			free(tmpfile);

			if(!getfilename || (getfilename && stricmp(getfilename, file) == 0))
			{
				pipeit("\n%s", file);
				flush;
				dcpr_init_file();               // initialize decompression of file
				if (!f_err)
				{
					if (test ||
						(wrhan = create_dest_file(file, (INT) fhead.ATTR))<0)
					{
						if (test || adat.sol)
							analyze_file();        // analyze file
					}
					else
					{
						extract_file();           // extract it
#ifdef DOS                               // set file time
						_dos_setftime(wrhan, (USHORT) (fhead.FTIME >> 16), (USHORT) fhead.FTIME);
#endif
						close(wrhan);
#if defined(__OS2__) || defined(__EMX__)
						{
							FILESTATUS3 fileinfo;

							DosQueryPathInfo(file, FIL_STANDARD, &fileinfo, sizeof(FILESTATUS3));
							*((USHORT*)&fileinfo.fdateCreation)   = (USHORT)(fhead.FTIME >> 16);
							*((USHORT*)&fileinfo.ftimeCreation)   = (USHORT)fhead.FTIME;
							*((USHORT*)&fileinfo.fdateLastAccess) = (USHORT)(fhead.FTIME >> 16);
							*((USHORT*)&fileinfo.ftimeLastAccess) = (USHORT)fhead.FTIME;
							*((USHORT*)&fileinfo.fdateLastWrite)  = (USHORT)(fhead.FTIME >> 16);
							*((USHORT*)&fileinfo.ftimeLastWrite)  = (USHORT)fhead.FTIME;
							DosSetPathInfo(file, FIL_STANDARD, (PVOID)&fileinfo, sizeof(FILESTATUS3), 0);
						}
#endif
#ifdef DOS                               // set file attributes
						_dos_setfileattr(file, (UINT) fhead.ATTR);
#endif
#ifdef AMIGA
					 {                         // set file date and time
						 struct DateTime dt;
						 char Date[9], Time[9];
						 ULONG tstamp=fhead.FTIME;

						 sprintf(Date, "%02d-%02d-%02d", ts_year(tstamp)-1900, ts_month(tstamp), ts_day(tstamp));
						 sprintf(Time, "%02d:%02d:%02d", ts_hour(tstamp), ts_min(tstamp), ts_sec(tstamp));

						 dt.dat_Format = FORMAT_INT;
						 dt.dat_Flags  = 0;
						 dt.dat_StrDate= Date;
						 dt.dat_StrTime= Time;

						 if (StrToDate(&dt))
							 SetFileDate(file, &dt.dat_Stamp);
					 }
#endif
					 if (f_err)
						 remove(file);
					}
				}
			}
		}
	}
}

unsigned percentage(ULONG p, ULONG d)
{
	return (unsigned)( d ? (d/2+p*100)/d : 100 );
}

int installer_unpack(CHAR * filename, int operation)              // processes the archive
{
	init_unace();                              // initialize unace
	strcpy(aname, "installer");                    // get archive name

	if(filename)
		f_ovrall=1;

	if (open_archive(1))                       // open archive to process
	{
		if (adat.vol_num)
			pipeit("\nFirst volume of archive required!\n");
		else
		{
			if(operation == 2)
				extract_files(0, 0, filename);
		}
#if !defined(__EMX__) && !defined(__OS2__)
		fclose(farchan);
#endif
		aceclose(archan);
		if (f_err)
		{
			pipeit("\nError occurred\n");
			if (f_criterr)
				pipeit("Critical error on drive %c\n", f_criterr);
		}
	}

	done_unace();
	return 0;
}
Commit	Line	Data
f6bcfd97 BP	1	/* ------------------------------------------------------------------------ */
	2	/* */
	3	/* Main file of public UNACE. */
	4	/* */
	5	/* ------------------------------------------------------------------------ */
	6
	7
	8	#define INCL_WIN /* Window Manager Functions */
	9	#define INCL_DOS
	10	#define INCL_BASE
	11
	12
	13	//--------------- include general files ------------------------------------//
	14	#include <ctype.h> // tolower()
	15	#include <fcntl.h> // open()
	16	#include <stdio.h> // printf() sprintf() remove()
	17	#include <stdlib.h> // malloc()
	18	#include <string.h> // str*()
	19	#include <sys/types.h>
	20	#include <sys/stat.h> // S_I* AMIGA: fstat()
	21	#if (!defined(__EMX__) && !defined(__OS2__) && !defined(WINNT) && !defined(WIN32)) \|\| defined(__CYGWIN__)
	22	#include <sys/errno.h>
	23	#endif
	24
	25	#if !defined(__EMX__) && !defined(__OS2__) && !defined(WIN32) && !defined(WINNT)
	26	#define stricmp strcasecmp
	27	#endif
	28
	29	#include "install.h"
	30	#include "instsup.h"
	31	extern int installstate;
	32
	33	off_t acelseek(off_t offset, int whence);
	34	int aceread(void *buf, size_t count);
	35	int aceopen(const char *path, int flags);
	36	int aceclose(int fd);
	37	int acesize(void);
	38	int acetell(int fd);
	39	char replacestr(char str1, char str2, char str3);
	40
	41	//--------------- include unace specific header files ----------------------//
	42	#include "os.h"
	43
	44	#include "globals.h"
	45	#include "portable.h"
	46	#include "uac_comm.h"
	47	#include "uac_crc.h"
	48	#include "uac_crt.h"
	49	#include "uac_dcpr.h"
	50	#include "uac_sys.h"
	51
	52	#ifdef CRYPT
	53	#include "unace_ps.h"
	54	#endif /* CRYPT */
	55
	56
	57
	58
	59	//--------------- BEGIN OF UNACE ROUTINES ----------------------------------//
	60
	61	int pipeit(char *format, ...)
	62	{
	63	/* Do nothing ... perhaps pipe this somewhere in the future */
	64	return 0;
65	}
66
67	void init_unace(void) // initializes unace
68	{
69	buf_rd =malloc(size_rdb * sizeof(ULONG)); // Allocate buffers: increase
70	buf =malloc(size_buf); // sizes when possible to speed
71	buf_wr =malloc(size_wrb); // up the program
72	readbuf=malloc(size_headrdb);
73
74	if (buf_rd ==NULL \|\|
75	buf ==NULL \|\|
76	buf_wr ==NULL \|\|
77	readbuf==NULL )
78	f_err = ERR_MEM;
79
80	make_crctable(); // initialize CRC table
81	dcpr_init(); // initialize decompression
82
83	set_handler(); // ctrl+break etc.
84	}
85
86	void done_unace(void)
87	{
88	if (buf_rd ) free(buf_rd );
89	if (buf ) free(buf );
90	if (buf_wr ) free(buf_wr );
91	if (readbuf ) free(readbuf );
92	if (dcpr_text) free(dcpr_text);
93	}
94
95	INT read_header(INT print_err) // reads any header from archive
96	{
97	USHORT rd,
98	head_size,
99	crc_ok;
100	LONG crc;
101	UCHAR *tp=readbuf;
102
103	acelseek(skipsize, SEEK_CUR); // skip ADDSIZE block
104
105	if (aceread(&head, 4)<4)
106	return (0); // read CRC and header size
107
108	#ifdef HI_LO_BYTE_ORDER
109	WORDswap(&head.HEAD_CRC);
110	WORDswap(&head.HEAD_SIZE);
111	#endif
112	// read size_headrdb bytes into
113	head_size = head.HEAD_SIZE; // header structure
114	rd = (head_size > size_headrdb) ? size_headrdb : head_size;
115	if (aceread(readbuf, rd) < rd)
116	return (0);
117	head_size -= rd;
118	crc = getcrc(CRC_MASK, readbuf, rd);
119
120	while (head_size) // skip rest of header
121	{
122	rd = (head_size > size_buf) ? size_buf : head_size;
123	if (aceread(buf, rd) < rd)
124	return (0);
125	head_size -= rd;
126	crc = getcrc(crc, (UCHAR*)buf, rd);
127	}
128
129	head.HEAD_TYPE =*tp++; // generic buffer to head conversion
130	head.HEAD_FLAGS=BUFP2WORD(tp);
131
132	if (head.HEAD_FLAGS & ACE_ADDSIZE)
133	skipsize = head.ADDSIZE = BUF2LONG(tp); // get ADDSIZE
134	else
135	skipsize = 0;
136
137	// check header CRC
138	if (!(crc_ok = head.HEAD_CRC == (crc & 0xffff)) && print_err)
139	pipeit("\nError: archive is broken\n");
140	else
141	switch (head.HEAD_TYPE) // specific buffer to head conversion
142	{
143	case MAIN_BLK:
144	memcpy(mhead.ACESIGN, tp, acesign_len); tp+=acesign_len;
145	mhead.VER_MOD=*tp++;
146	mhead.VER_CR =*tp++;
147	mhead.HOST_CR=*tp++;
148	mhead.VOL_NUM=*tp++;
149	mhead.TIME_CR=BUFP2LONG(tp);
150	mhead.RES1 =BUFP2WORD(tp);
151	mhead.RES2 =BUFP2WORD(tp);
152	mhead.RES =BUFP2LONG(tp);
153	mhead.AV_SIZE=*tp++;
154	memcpy(mhead.AV, tp, rd-(USHORT)(tp-readbuf));
155	break;
156	case FILE_BLK:
157	fhead.PSIZE =BUFP2LONG(tp);
158	fhead.SIZE =BUFP2LONG(tp);
159	fhead.FTIME =BUFP2LONG(tp);
160	fhead.ATTR =BUFP2LONG(tp);
161	fhead.CRC32 =BUFP2LONG(tp);
162	fhead.TECH.TYPE =*tp++;
163	fhead.TECH.QUAL =*tp++;
164	fhead.TECH.PARM =BUFP2WORD(tp);
165	fhead.RESERVED =BUFP2WORD(tp);
166	fhead.FNAME_SIZE=BUFP2WORD(tp);
167	memcpy(fhead.FNAME, tp, rd-(USHORT)(tp-readbuf));
168	break;
169	// default: (REC_BLK and future things):
170	// do nothing 'cause isn't needed for extraction
171	}
172
173	return (crc_ok);
174	}
175	// maximum SFX module size
176	#define max_sfx_size 65536 // (needed by read_arc_head)
177
178	INT read_arc_head(void) // searches for the archive header and reads it
179	{
180	INT i,
181	flags,
182	buf_pos = 0;
183	LONG arc_head_pos,
184	old_fpos,
185	fpos = 0;
186	struct stat st;
187
188	fstat(archan, &st);
189
190	memset(buf, 0, size_buf);
191
192	while (acetell(archan)<acesize() && fpos < max_sfx_size)
193	{
194	old_fpos = fpos;
195	fpos += aceread(&buf[buf_pos], size_buf - buf_pos);
196
197	for (i = 0; i < size_buf; i++) // look for the acesign
198	{
199	if (!memcmp(acesign, &buf[i], acesign_len))
200	{
201	// seek to the probable begin
202	// of the archive
203	arc_head_pos = old_fpos + i - buf_pos - bytes_before_acesign;
204	acelseek(arc_head_pos, SEEK_SET);
205	if (read_header(0)) // try to read archive header
206	{
207	flags = mhead.HEAD_FLAGS;
208	adat.sol = (flags & ACE_SOLID) > 0;
209	adat.vol = (flags & ACE_MULT_VOL) > 0;
210	adat.vol_num = mhead.VOL_NUM;
211	adat.time_cr = mhead.TIME_CR;
212	return (1);
213	}
214	}
215	}
216	// was no archive header,
217	// continue search
218	acelseek(fpos, SEEK_SET);
219	memcpy(buf, &buf[size_buf - 512], 512);
220	buf_pos = 512; // keep 512 old bytes
221	}
222	return (0);
223	}
224
225	INT open_archive(INT print_err) // opens archive (or volume)
226	{
227	CHAR av_str[80];
228
229	#if defined(__OS2_) \|\| defined(__EMX__) \|\| defined(WIN32)
230	archan = aceopen(aname, O_RDONLY \| O_BINARY); // open file
231	#else
232	archan = aceopen(aname, O_RDONLY); // open file
233	#endif
234	#if !defined(__EMX__) && !defined(__OS2__)
235	farchan = fdopen(archan, "rb");
236	#endif
237
238	if (archan == -1)
239	{
240	error("\nError opening file %s", aname);
241	return (0);
242	}
243	if (!read_arc_head()) // read archive header
244	{
245	error("Invalid embedded archive file.");
246	#if !defined(__EMX__) && !defined(__OS2__)
247	fclose(farchan);
248	#endif
249	aceclose(archan);
250	return (0);
251	}
252
253	pipeit("\nProcessing archive: %s\n\n", aname);
254	if (head.HEAD_FLAGS & ACE_AV)
255	{
256	pipeit("Authenticity Verification:"); // print the AV
257	sprintf(av_str, "\ncreated on %d.%d.%d by ",
258	ts_day(adat.time_cr), ts_month(adat.time_cr), ts_year(adat.time_cr));
259	pipeit(av_str);
260	strncpy(av_str, (CHAR*)mhead.AV, mhead.AV_SIZE);
261	av_str[mhead.AV_SIZE] = 0;
262	pipeit("%s\n\n", av_str);
263	}
264	comment_out("Main comment:"); // print main comment
265	return (1);
266	}
267
268	void get_next_volname(void) // get file name of next volume
269	{
270	CHAR *cp;
271	INT num;
272
273	if ((cp = (CHAR ) strrchr(aname, '.')) == NULL \|\| !(cp + 1))
274	num = -1;
275	else
276	{
277	cp++;
278	num = ((cp + 1) - '0') 10 + *(cp + 2) - '0';
279	if (!in(num, 0, 99))
280	num = -1;
281	if (in(*cp, '0', '9'))
282	num += (cp - '0') 100;
283	}
284	num++;
285
286	if (num < 100)
287	*cp = 'C';
288	else
289	*cp = num / 100 + '0';
290	*(cp + 1) = (num / 10) % 10 + '0';
291	*(cp + 2) = num % 10 + '0';
292	}
293
294	INT proc_vol(void) // opens volume
295	{
296	INT i;
297	CHAR s[80];
298
299	if (!fileexists(aname) \|\| !f_allvol_pr)
300	{
301	do
302	{
303	sprintf(s, "Ready to process %s?", aname);
304	#if defined(__MINGW32__)
305	beep(500,500);
306	#else
307	beep();
308	#endif
309	i = confirm(s); // ask whether ready or not
310	f_allvol_pr = (i == 1); // "Always" --> process all volumes
311	if (i >= 2)
312	{
313	f_err = ERR_FOUND;
314	return (0);
315	}
316	}
317	while (!fileexists(aname));
318	}
319
320	if (!open_archive(1)) // open volume
321	{
322	pipeit("\nError while opening archive. File not found or archive broken.\n");
323	f_err = ERR_OPEN;
324	return (0);
325	}
326
327	return (1);
328	}
329
330	INT proc_next_vol(void) // opens next volume to process
331	{
332	#if !defined(__EMX__) && !defined(__OS2__)
333	fclose(farchan);
334	#endif
335	aceclose(archan); // close handle
336	get_next_volname(); // get file name of next volume
337
338	if (!proc_vol()) // try to open volume, read archive header
339	return 0;
340	if (!read_header(1)) // read 2nd header
341	{
342	f_err=ERR_READ;
343	return 0;
344	}
345	return 1;
346	}
347
348	INT read_adds_blk(CHAR * buffer, INT len) // reads part of ADD_SIZE block
349	{
350	INT rd = 0,
351	l = len;
352	LONG i;
353
354	#ifdef CRYPT
355	char *cbuffer=buffer;
356
357	if (head.HEAD_TYPE == FILE_BLK && (head.HEAD_FLAGS & ACE_PASSW))
358	len = crypt_len(len);
359	#endif /* CRYPT */
360	while (!f_err && len && skipsize)
361	{
362	i = (skipsize > len) ? len : skipsize;
363	skipsize -= i;
364
365	/* How do I test failure when compiling -mno-cygwin? */
366	#if !defined(__MINGW32__)
367	errno = 0;
368	#endif
369	rd += aceread(buffer, i);
370	#if !defined(__MINGW32__)
371	if (errno)
372	{
373	error("\nRead error\n");
374	f_err = ERR_READ;
375	}
376	#endif
377
378	buffer += i;
379	len -= i;
380
381	if (!skipsize) // if block is continued on next volume
382	if (head.HEAD_FLAGS & ACE_SP_AFTER && !proc_next_vol())
383	break;
384	}
385	#ifdef CRYPT
386	if (head.HEAD_TYPE == FILE_BLK && (head.HEAD_FLAGS & ACE_PASSW))
387	decrypt(cbuffer, rd);
388	#endif /* CRYPT */
389
390	return (rd > l ? l : rd);
391	}
392
393	void crc_print(void) // checks CRC, prints message
394	{
395	INT crc_not_ok = rd_crc != fhead.CRC32; /* check CRC of file */
396
397	if(crc_not_ok && installstate != ABORTED)
398	error("CRC error reading archive!");
399	}
400
401	void analyze_file(void) // analyzes one file (for solid archives)
402	{
403	pipeit("\n Analyzing");
404	flush;
405	while (!cancel() && (dcpr_adds_blk(buf_wr, size_wrb))) // decompress only
406	;
407	crc_print();
408	}
409
410	void extract_file(void) // extracts one file
411	{
412	INT rd;
413
414	pipeit("\n Extracting");
415	flush; // decompress block
416	while (!cancel() && (rd = dcpr_adds_blk(buf_wr, size_wrb)))
417	{
418	if (write(wrhan, buf_wr, rd) != rd) // write block
419	{
420	error("\nWrite error\n");
421	f_err = ERR_WRITE;
422	}
423	}
424	crc_print();
425	}
426
427
428	/* extracts or tests all files of the archive
429	*/
430	void extract_files(int nopath, int test, char *getfilename)
431	{
432	CHAR file[PATH_MAX];
433	char *tmpfile;
434	extern unsigned current_file;
435	extern char installdir2[];
436
437	while (!cancel() && read_header(1))
438	{
439	if (head.HEAD_TYPE == FILE_BLK)
440	{
441	if(installstate == ABORTED)
442	return;
443	current_file++;
444	if(installstate == INSTALLING)
445	DoGUI();
446
447	comment_out("File comment:"); // show file comment
448	ace_fname(file, &head, nopath); // get file name
449
450	/* We allow expansion of "userdir" to the selected directory by the user */
451	tmpfile = replacestr(file, "USERDIR", installdir2);
452	strcpy(file, tmpfile);
453	free(tmpfile);
454
455	if(!getfilename \|\| (getfilename && stricmp(getfilename, file) == 0))
456	{
457	pipeit("\n%s", file);
458	flush;
459	dcpr_init_file(); // initialize decompression of file
460	if (!f_err)
461	{
462	if (test \|\|
463	(wrhan = create_dest_file(file, (INT) fhead.ATTR))<0)
464	{
465	if (test \|\| adat.sol)
466	analyze_file(); // analyze file
467	}
468	else
469	{
470	extract_file(); // extract it
471	#ifdef DOS // set file time
472	_dos_setftime(wrhan, (USHORT) (fhead.FTIME >> 16), (USHORT) fhead.FTIME);
473	#endif
474	close(wrhan);
475	#if defined(__OS2__) \|\| defined(__EMX__)
476	{
477	FILESTATUS3 fileinfo;
478
479	DosQueryPathInfo(file, FIL_STANDARD, &fileinfo, sizeof(FILESTATUS3));
480	((USHORT)&fileinfo.fdateCreation) = (USHORT)(fhead.FTIME >> 16);
481	((USHORT)&fileinfo.ftimeCreation) = (USHORT)fhead.FTIME;
482	((USHORT)&fileinfo.fdateLastAccess) = (USHORT)(fhead.FTIME >> 16);
483	((USHORT)&fileinfo.ftimeLastAccess) = (USHORT)fhead.FTIME;
484	((USHORT)&fileinfo.fdateLastWrite) = (USHORT)(fhead.FTIME >> 16);
485	((USHORT)&fileinfo.ftimeLastWrite) = (USHORT)fhead.FTIME;
486	DosSetPathInfo(file, FIL_STANDARD, (PVOID)&fileinfo, sizeof(FILESTATUS3), 0);
487	}
488	#endif
489	#ifdef DOS // set file attributes
490	_dos_setfileattr(file, (UINT) fhead.ATTR);
491	#endif
492	#ifdef AMIGA
493	{ // set file date and time
494	struct DateTime dt;
495	char Date[9], Time[9];
496	ULONG tstamp=fhead.FTIME;
497
498	sprintf(Date, "%02d-%02d-%02d", ts_year(tstamp)-1900, ts_month(tstamp), ts_day(tstamp));
499	sprintf(Time, "%02d:%02d:%02d", ts_hour(tstamp), ts_min(tstamp), ts_sec(tstamp));
500
501	dt.dat_Format = FORMAT_INT;
502	dt.dat_Flags = 0;
503	dt.dat_StrDate= Date;
504	dt.dat_StrTime= Time;
505
506	if (StrToDate(&dt))
507	SetFileDate(file, &dt.dat_Stamp);
508	}
509	#endif
510	if (f_err)
511	remove(file);
512	}
513	}
514	}
515	}
516	}
517	}
518
519	unsigned percentage(ULONG p, ULONG d)
520	{
521	return (unsigned)( d ? (d/2+p*100)/d : 100 );
522	}
523
524	int installer_unpack(CHAR * filename, int operation) // processes the archive
525	{
526	init_unace(); // initialize unace
527	strcpy(aname, "installer"); // get archive name
528
529	if(filename)
530	f_ovrall=1;
531
532	if (open_archive(1)) // open archive to process
533	{
534	if (adat.vol_num)
535	pipeit("\nFirst volume of archive required!\n");
536	else
537	{
538	if(operation == 2)
539	extract_files(0, 0, filename);
540	}
541	#if !defined(__EMX__) && !defined(__OS2__)
542	fclose(farchan);
543	#endif
544	aceclose(archan);
545	if (f_err)
546	{
547	pipeit("\nError occurred\n");
548	if (f_criterr)
549	pipeit("Critical error on drive %c\n", f_criterr);
550	}
551	}
552
553	done_unace();
554	return 0;
555	}