/*
 IMPORTANT NOTE: IF THIS FILE IS CHANGED, PCBUILD\BDIST_WININST.VCXPROJ MUST
 BE REBUILT AS WELL.

 IF CHANGES TO THIS FILE ARE CHECKED IN, THE RECOMPILED BINARIES MUST BE
 CHECKED IN AS WELL!
*/

#include <windows.h>

#include "zlib.h"

#include <stdio.h>
#include <stdarg.h>

#include "archive.h"

/* Convert unix-path to dos-path */
static void normpath(char *path)
{
 while (path && *path) {
 if (*path == '/')
 *path = '\\';
 ++path;
 }
}

BOOL ensure_directory(char *pathname, char *new_part, NOTIFYPROC notify)
{
 while (new_part && *new_part && (new_part = strchr(new_part, '\\'))) {
 DWORD attr;
 *new_part = '0円';
 attr = GetFileAttributes(pathname);
 if (attr == -1) {
 /* nothing found */
 if (!CreateDirectory(pathname, NULL) && notify)
 notify(SYSTEM_ERROR,
 "CreateDirectory (%s)", pathname);
 else
 notify(DIR_CREATED, pathname);
 }
 if (attr & FILE_ATTRIBUTE_DIRECTORY) {
 ;
 } else {
 SetLastError(183);
 if (notify)
 notify(SYSTEM_ERROR,
 "CreateDirectory (%s)", pathname);
 }
 *new_part = '\\';
 ++new_part;
 }
 return TRUE;
}

/* XXX Should better explicitly specify
 * uncomp_size and file_times instead of pfhdr!
 */
char *map_new_file(DWORD flags, char *filename,
 char *pathname_part, int size,
 WORD wFatDate, WORD wFatTime,
 NOTIFYPROC notify)
{
 HANDLE hFile, hFileMapping;
 char *dst;
 FILETIME ft;

 try_again:
 if (!flags)
 flags = CREATE_NEW;
 hFile = CreateFile(filename,
 GENERIC_WRITE | GENERIC_READ,
 0, NULL,
 flags,
 FILE_ATTRIBUTE_NORMAL, NULL);
 if (hFile == INVALID_HANDLE_VALUE) {
 DWORD x = GetLastError();
 switch (x) {
 case ERROR_FILE_EXISTS:
 if (notify && notify(CAN_OVERWRITE, filename))
 hFile = CreateFile(filename,
 GENERIC_WRITE|GENERIC_READ,
 0, NULL,
 CREATE_ALWAYS,
 FILE_ATTRIBUTE_NORMAL,
 NULL);
 else {
 if (notify)
 notify(FILE_OVERWRITTEN, filename);
 return NULL;
 }
 break;
 case ERROR_PATH_NOT_FOUND:
 if (ensure_directory(filename, pathname_part, notify))
 goto try_again;
 else
 return FALSE;
 break;
 default:
 SetLastError(x);
 break;
 }
 }
 if (hFile == INVALID_HANDLE_VALUE) {
 if (notify)
 notify (SYSTEM_ERROR, "CreateFile (%s)", filename);
 return NULL;
 }

 if (notify)
 notify(FILE_CREATED, filename);

 DosDateTimeToFileTime(wFatDate, wFatTime, &ft);
 SetFileTime(hFile, &ft, &ft, &ft);


 if (size == 0) {
 /* We cannot map a zero-length file (Also it makes
 no sense */
 CloseHandle(hFile);
 return NULL;
 }

 hFileMapping = CreateFileMapping(hFile,
 NULL, PAGE_READWRITE, 0, size, NULL);

 CloseHandle(hFile);

 if (hFileMapping == NULL) {
 if (notify)
 notify(SYSTEM_ERROR,
 "CreateFileMapping (%s)", filename);
 return NULL;
 }

 dst = MapViewOfFile(hFileMapping,
 FILE_MAP_WRITE, 0, 0, 0);

 CloseHandle(hFileMapping);

 if (!dst) {
 if (notify)
 notify(SYSTEM_ERROR, "MapViewOfFile (%s)", filename);
 return NULL;
 }
 return dst;
}


BOOL
extract_file(char *dst, char *src, int method, int comp_size,
 int uncomp_size, NOTIFYPROC notify)
{
 z_stream zstream;
 int result;

 if (method == Z_DEFLATED) {
 int x;
 memset(&zstream, 0, sizeof(zstream));
 zstream.next_in = src;
 zstream.avail_in = comp_size+1;
 zstream.next_out = dst;
 zstream.avail_out = uncomp_size;

/* Apparently an undocumented feature of zlib: Set windowsize
 to negative values to suppress the gzip header and be compatible with
 zip! */
 result = TRUE;
 if (Z_OK != (x = inflateInit2(&zstream, -15))) {
 if (notify)
 notify(ZLIB_ERROR,
 "inflateInit2 returns %d", x);
 result = FALSE;
 goto cleanup;
 }
 if (Z_STREAM_END != (x = inflate(&zstream, Z_FINISH))) {
 if (notify)
 notify(ZLIB_ERROR,
 "inflate returns %d", x);
 result = FALSE;
 }
 cleanup:
 if (Z_OK != (x = inflateEnd(&zstream))) {
 if (notify)
 notify (ZLIB_ERROR,
 "inflateEnd returns %d", x);
 result = FALSE;
 }
 } else if (method == 0) {
 memcpy(dst, src, uncomp_size);
 result = TRUE;
 } else
 result = FALSE;
 UnmapViewOfFile(dst);
 return result;
}

/* Open a zip-compatible archive and extract all files
 * into the specified directory (which is assumed to exist)
 */
BOOL
unzip_archive(SCHEME *scheme, char *dirname, char *data, DWORD size,
 NOTIFYPROC notify)
{
 int n;
 char pathname[MAX_PATH];
 char *new_part;

 /* read the end of central directory record */
 struct eof_cdir *pe = (struct eof_cdir *)&data[size - sizeof
 (struct eof_cdir)];

 int arc_start = size - sizeof (struct eof_cdir) - pe->nBytesCDir -
 pe->ofsCDir;

 /* set position to start of central directory */
 int pos = arc_start + pe->ofsCDir;

 /* make sure this is a zip file */
 if (pe->tag != 0x06054b50)
 return FALSE;

 /* Loop through the central directory, reading all entries */
 for (n = 0; n < pe->nTotalCDir; ++n) {
 int i;
 char *fname;
 char *pcomp;
 char *dst;
 struct cdir *pcdir;
 struct fhdr *pfhdr;

 pcdir = (struct cdir *)&data[pos];
 pfhdr = (struct fhdr *)&data[pcdir->ofs_local_header +
 arc_start];

 if (pcdir->tag != 0x02014b50)
 return FALSE;
 if (pfhdr->tag != 0x04034b50)
 return FALSE;
 pos += sizeof(struct cdir);
 fname = (char *)&data[pos]; /* This is not null terminated! */
 pos += pcdir->fname_length + pcdir->extra_length +
 pcdir->comment_length;

 pcomp = &data[pcdir->ofs_local_header
 + sizeof(struct fhdr)
 + arc_start
 + pfhdr->fname_length
 + pfhdr->extra_length];

 /* dirname is the Python home directory (prefix) */
 strcpy(pathname, dirname);
 if (pathname[strlen(pathname)-1] != '\\')
 strcat(pathname, "\\");
 new_part = &pathname[lstrlen(pathname)];
 /* we must now match the first part of the pathname
 * in the archive to a component in the installation
 * scheme (PURELIB, PLATLIB, HEADERS, SCRIPTS, or DATA)
 * and replace this part by the one in the scheme to use
 */
 for (i = 0; scheme[i].name; ++i) {
 if (0 == strnicmp(scheme[i].name, fname,
 strlen(scheme[i].name))) {
 char *rest;
 int len;

 /* length of the replaced part */
 int namelen = strlen(scheme[i].name);

 strcat(pathname, scheme[i].prefix);

 rest = fname + namelen;
 len = pfhdr->fname_length - namelen;

 if ((pathname[strlen(pathname)-1] != '\\')
 && (pathname[strlen(pathname)-1] != '/'))
 strcat(pathname, "\\");
 /* Now that pathname ends with a separator,
 * we must make sure rest does not start with
 * an additional one.
 */
 if ((rest[0] == '\\') || (rest[0] == '/')) {
 ++rest;
 --len;
 }

 strncat(pathname, rest, len);
 goto Done;
 }
 }
 /* no prefix to replace found, go unchanged */
 strncat(pathname, fname, pfhdr->fname_length);
 Done:
 normpath(pathname);
 if (pathname[strlen(pathname)-1] != '\\') {
 /*
 * The local file header (pfhdr) does not always
 * contain the compressed and uncompressed sizes of
 * the data depending on bit 3 of the flags field. So
 * it seems better to use the data from the central
 * directory (pcdir).
 */
 dst = map_new_file(0, pathname, new_part,
 pcdir->uncomp_size,
 pcdir->last_mod_file_date,
 pcdir->last_mod_file_time, notify);
 if (dst) {
 if (!extract_file(dst, pcomp, pfhdr->method,
 pcdir->comp_size,
 pcdir->uncomp_size,
 notify))
 return FALSE;
 } /* else ??? */
 }
 if (notify)
 notify(NUM_FILES, new_part, (int)pe->nTotalCDir,
 (int)n+1);
 }
 return TRUE;
}