/* ------------------------------------------------------------------------ */
/*                                                                          */
/*      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;
}