From 8eef239b457ea15aa5868413ee73a29470757793 Mon Sep 17 00:00:00 2001 From: John Preston Date: Sat, 30 Jan 2016 19:31:10 +0300 Subject: [PATCH] crash catch + report added for Windows version --- Telegram/SourceFiles/_other/crypt.h | 131 ++ Telegram/SourceFiles/_other/ioapi.h | 208 +++ Telegram/SourceFiles/_other/zip.c | 2007 +++++++++++++++++++++++ Telegram/SourceFiles/_other/zip.h | 362 ++++ Telegram/SourceFiles/app.cpp | 11 +- Telegram/SourceFiles/application.cpp | 28 +- Telegram/SourceFiles/application.h | 4 +- Telegram/SourceFiles/dropdown.cpp | 2 +- Telegram/SourceFiles/facades.cpp | 8 + Telegram/SourceFiles/facades.h | 2 + Telegram/SourceFiles/gui/images.cpp | 8 +- Telegram/SourceFiles/gui/images.h | 34 +- Telegram/SourceFiles/gui/twidget.cpp | 17 +- Telegram/SourceFiles/gui/twidget.h | 4 + Telegram/SourceFiles/logs.cpp | 11 + Telegram/SourceFiles/pspecific_wnd.cpp | 27 +- Telegram/SourceFiles/settings.cpp | 4 + Telegram/SourceFiles/settingswidget.cpp | 12 +- Telegram/SourceFiles/settingswidget.h | 10 +- Telegram/SourceFiles/stdafx.h | 1 + Telegram/SourceFiles/sysbuttons.cpp | 7 +- Telegram/SourceFiles/title.cpp | 11 +- Telegram/SourceFiles/window.cpp | 1054 +++++++++++- Telegram/SourceFiles/window.h | 184 ++- Telegram/Telegram.vcxproj | 8 +- Telegram/Telegram.vcxproj.filters | 12 + 26 files changed, 4057 insertions(+), 110 deletions(-) create mode 100644 Telegram/SourceFiles/_other/crypt.h create mode 100644 Telegram/SourceFiles/_other/ioapi.h create mode 100644 Telegram/SourceFiles/_other/zip.c create mode 100644 Telegram/SourceFiles/_other/zip.h diff --git a/Telegram/SourceFiles/_other/crypt.h b/Telegram/SourceFiles/_other/crypt.h new file mode 100644 index 000000000..1e9e8200b --- /dev/null +++ b/Telegram/SourceFiles/_other/crypt.h @@ -0,0 +1,131 @@ +/* crypt.h -- base code for crypt/uncrypt ZIPfile + + + Version 1.01e, February 12th, 2005 + + Copyright (C) 1998-2005 Gilles Vollant + + This code is a modified version of crypting code in Infozip distribution + + The encryption/decryption parts of this source code (as opposed to the + non-echoing password parts) were originally written in Europe. The + whole source package can be freely distributed, including from the USA. + (Prior to January 2000, re-export from the US was a violation of US law.) + + This encryption code is a direct transcription of the algorithm from + Roger Schlafly, described by Phil Katz in the file appnote.txt. This + file (appnote.txt) is distributed with the PKZIP program (even in the + version without encryption capabilities). + + If you don't need crypting in your application, just define symbols + NOCRYPT and NOUNCRYPT. + + This code support the "Traditional PKWARE Encryption". + + The new AES encryption added on Zip format by Winzip (see the page + http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong + Encryption is not supported. +*/ + +#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) + +/*********************************************************************** + * Return the next byte in the pseudo-random sequence + */ +static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab) +{ + unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an + * unpredictable manner on 16-bit systems; not a problem + * with any known compiler so far, though */ + + temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; + return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); +} + +/*********************************************************************** + * Update the encryption keys with the next byte of plain text + */ +static int update_keys(unsigned long* pkeys,const z_crc_t* pcrc_32_tab,int c) +{ + (*(pkeys+0)) = CRC32((*(pkeys+0)), c); + (*(pkeys+1)) += (*(pkeys+0)) & 0xff; + (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; + { + register int keyshift = (int)((*(pkeys+1)) >> 24); + (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); + } + return c; +} + + +/*********************************************************************** + * Initialize the encryption keys and the random header according to + * the given password. + */ +static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t* pcrc_32_tab) +{ + *(pkeys+0) = 305419896L; + *(pkeys+1) = 591751049L; + *(pkeys+2) = 878082192L; + while (*passwd != '\0') { + update_keys(pkeys,pcrc_32_tab,(int)*passwd); + passwd++; + } +} + +#define zdecode(pkeys,pcrc_32_tab,c) \ + (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) + +#define zencode(pkeys,pcrc_32_tab,c,t) \ + (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) + +#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED + +#define RAND_HEAD_LEN 12 + /* "last resort" source for second part of crypt seed pattern */ +# ifndef ZCR_SEED2 +# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ +# endif + +static int crypthead(const char* passwd, /* password string */ + unsigned char* buf, /* where to write header */ + int bufSize, + unsigned long* pkeys, + const z_crc_t* pcrc_32_tab, + unsigned long crcForCrypting) +{ + int n; /* index in random header */ + int t; /* temporary */ + int c; /* random byte */ + unsigned char header[RAND_HEAD_LEN-2]; /* random header */ + static unsigned calls = 0; /* ensure different random header each time */ + + if (bufSize> 7) & 0xff; + header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); + } + /* Encrypt random header (last two bytes is high word of crc) */ + init_keys(passwd, pkeys, pcrc_32_tab); + for (n = 0; n < RAND_HEAD_LEN-2; n++) + { + buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); + } + buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); + buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); + return n; +} + +#endif diff --git a/Telegram/SourceFiles/_other/ioapi.h b/Telegram/SourceFiles/_other/ioapi.h new file mode 100644 index 000000000..8dcbdb06e --- /dev/null +++ b/Telegram/SourceFiles/_other/ioapi.h @@ -0,0 +1,208 @@ +/* ioapi.h -- IO base function header for compress/uncompress .zip + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + + Changes + + Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this) + Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux. + More if/def section may be needed to support other platforms + Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows. + (but you should use iowin32.c for windows instead) + +*/ + +#ifndef _ZLIBIOAPI64_H +#define _ZLIBIOAPI64_H + +#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__)) + + // Linux needs this to support file operation on files larger then 4+GB + // But might need better if/def to select just the platforms that needs them. + + #ifndef __USE_FILE_OFFSET64 + #define __USE_FILE_OFFSET64 + #endif + #ifndef __USE_LARGEFILE64 + #define __USE_LARGEFILE64 + #endif + #ifndef _LARGEFILE64_SOURCE + #define _LARGEFILE64_SOURCE + #endif + #ifndef _FILE_OFFSET_BIT + #define _FILE_OFFSET_BIT 64 + #endif + +#endif + +#include +#include +#include "zlib.h" + +#if defined(USE_FILE32API) +#define fopen64 fopen +#define ftello64 ftell +#define fseeko64 fseek +#else +#ifdef __FreeBSD__ +#define fopen64 fopen +#define ftello64 ftello +#define fseeko64 fseeko +#endif +#ifdef _MSC_VER + #define fopen64 fopen + #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC))) + #define ftello64 _ftelli64 + #define fseeko64 _fseeki64 + #else // old MSC + #define ftello64 ftell + #define fseeko64 fseek + #endif +#endif +#endif + +/* +#ifndef ZPOS64_T + #ifdef _WIN32 + #define ZPOS64_T fpos_t + #else + #include + #define ZPOS64_T uint64_t + #endif +#endif +*/ + +#ifdef HAVE_MINIZIP64_CONF_H +#include "mz64conf.h" +#endif + +/* a type choosen by DEFINE */ +#ifdef HAVE_64BIT_INT_CUSTOM +typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T; +#else +#ifdef HAS_STDINT_H +#include "stdint.h" +typedef uint64_t ZPOS64_T; +#else + +/* Maximum unsigned 32-bit value used as placeholder for zip64 */ +#define MAXU32 0xffffffff + +#if defined(_MSC_VER) || defined(__BORLANDC__) +typedef unsigned __int64 ZPOS64_T; +#else +typedef unsigned long long int ZPOS64_T; +#endif +#endif +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define ZLIB_FILEFUNC_SEEK_CUR (1) +#define ZLIB_FILEFUNC_SEEK_END (2) +#define ZLIB_FILEFUNC_SEEK_SET (0) + +#define ZLIB_FILEFUNC_MODE_READ (1) +#define ZLIB_FILEFUNC_MODE_WRITE (2) +#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) + +#define ZLIB_FILEFUNC_MODE_EXISTING (4) +#define ZLIB_FILEFUNC_MODE_CREATE (8) + + +#ifndef ZCALLBACK + #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) + #define ZCALLBACK CALLBACK + #else + #define ZCALLBACK + #endif +#endif + + + + +typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); +typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); +typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); +typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); +typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); + +typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); +typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); + + +/* here is the "old" 32 bits structure structure */ +typedef struct zlib_filefunc_def_s +{ + open_file_func zopen_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell_file_func ztell_file; + seek_file_func zseek_file; + close_file_func zclose_file; + testerror_file_func zerror_file; + voidpf opaque; +} zlib_filefunc_def; + +typedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream)); +typedef long (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)); +typedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, const void* filename, int mode)); + +typedef struct zlib_filefunc64_def_s +{ + open64_file_func zopen64_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell64_file_func ztell64_file; + seek64_file_func zseek64_file; + close_file_func zclose_file; + testerror_file_func zerror_file; + voidpf opaque; +} zlib_filefunc64_def; + +void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def)); +void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); + +/* now internal definition, only for zip.c and unzip.h */ +typedef struct zlib_filefunc64_32_def_s +{ + zlib_filefunc64_def zfile_func64; + open_file_func zopen32_file; + tell_file_func ztell32_file; + seek_file_func zseek32_file; +} zlib_filefunc64_32_def; + + +#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +//#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream)) +//#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode)) +#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream)) +#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream)) + +voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)); +long call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)); +ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)); + +void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32); + +#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode))) +#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream))) +#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode))) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Telegram/SourceFiles/_other/zip.c b/Telegram/SourceFiles/_other/zip.c new file mode 100644 index 000000000..ea54853e8 --- /dev/null +++ b/Telegram/SourceFiles/_other/zip.c @@ -0,0 +1,2007 @@ +/* zip.c -- IO on .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + + Changes + Oct-2009 - Mathias Svensson - Remove old C style function prototypes + Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives + Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions. + Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data + It is used when recreting zip archive with RAW when deleting items from a zip. + ZIP64 data is automaticly added to items that needs it, and existing ZIP64 data need to be removed. + Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required) + Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer + +*/ + + +#include +#include +#include +#include +#include "zlib.h" +#include "zip.h" + +#ifdef STDC +# include +# include +# include +#endif +#ifdef NO_ERRNO_H + extern int errno; +#else +# include +#endif + + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +#ifndef VERSIONMADEBY +# define VERSIONMADEBY (0x0) /* platform depedent */ +#endif + +#ifndef Z_BUFSIZE +#define Z_BUFSIZE (64*1024) //(16384) +#endif + +#ifndef Z_MAXFILENAMEINZIP +#define Z_MAXFILENAMEINZIP (256) +#endif + +#ifndef ALLOC +# define ALLOC(size) (malloc(size)) +#endif +#ifndef TRYFREE +# define TRYFREE(p) {if (p) free(p);} +#endif + +/* +#define SIZECENTRALDIRITEM (0x2e) +#define SIZEZIPLOCALHEADER (0x1e) +*/ + +/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ + + +// NOT sure that this work on ALL platform +#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32)) + +#ifndef SEEK_CUR +#define SEEK_CUR 1 +#endif + +#ifndef SEEK_END +#define SEEK_END 2 +#endif + +#ifndef SEEK_SET +#define SEEK_SET 0 +#endif + +#ifndef DEF_MEM_LEVEL +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif +#endif +const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; + + +#define SIZEDATA_INDATABLOCK (4096-(4*4)) + +#define LOCALHEADERMAGIC (0x04034b50) +#define CENTRALHEADERMAGIC (0x02014b50) +#define ENDHEADERMAGIC (0x06054b50) +#define ZIP64ENDHEADERMAGIC (0x6064b50) +#define ZIP64ENDLOCHEADERMAGIC (0x7064b50) + +#define FLAG_LOCALHEADER_OFFSET (0x06) +#define CRC_LOCALHEADER_OFFSET (0x0e) + +#define SIZECENTRALHEADER (0x2e) /* 46 */ + +typedef struct linkedlist_datablock_internal_s +{ + struct linkedlist_datablock_internal_s* next_datablock; + uLong avail_in_this_block; + uLong filled_in_this_block; + uLong unused; /* for future use and alignement */ + unsigned char data[SIZEDATA_INDATABLOCK]; +} linkedlist_datablock_internal; + +typedef struct linkedlist_data_s +{ + linkedlist_datablock_internal* first_block; + linkedlist_datablock_internal* last_block; +} linkedlist_data; + + +typedef struct +{ + z_stream stream; /* zLib stream structure for inflate */ +#ifdef HAVE_BZIP2 + bz_stream bstream; /* bzLib stream structure for bziped */ +#endif + + int stream_initialised; /* 1 is stream is initialised */ + uInt pos_in_buffered_data; /* last written byte in buffered_data */ + + ZPOS64_T pos_local_header; /* offset of the local header of the file + currenty writing */ + char* central_header; /* central header data for the current file */ + uLong size_centralExtra; + uLong size_centralheader; /* size of the central header for cur file */ + uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */ + uLong flag; /* flag of the file currently writing */ + + int method; /* compression method of file currenty wr.*/ + int raw; /* 1 for directly writing raw data */ + Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ + uLong dosDate; + uLong crc32; + int encrypt; + int zip64; /* Add ZIP64 extened information in the extra field */ + ZPOS64_T pos_zip64extrainfo; + ZPOS64_T totalCompressedData; + ZPOS64_T totalUncompressedData; +#ifndef NOCRYPT + unsigned long keys[3]; /* keys defining the pseudo-random sequence */ + const z_crc_t* pcrc_32_tab; + int crypt_header_size; +#endif +} curfile64_info; + +typedef struct +{ + zlib_filefunc64_32_def z_filefunc; + voidpf filestream; /* io structore of the zipfile */ + linkedlist_data central_dir;/* datablock with central dir in construction*/ + int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ + curfile64_info ci; /* info on the file curretly writing */ + + ZPOS64_T begin_pos; /* position of the beginning of the zipfile */ + ZPOS64_T add_position_when_writting_offset; + ZPOS64_T number_entry; + +#ifndef NO_ADDFILEINEXISTINGZIP + char *globalcomment; +#endif + +} zip64_internal; + + +#ifndef NOCRYPT +#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED +#include "crypt.h" +#endif + +local linkedlist_datablock_internal* allocate_new_datablock() +{ + linkedlist_datablock_internal* ldi; + ldi = (linkedlist_datablock_internal*) + ALLOC(sizeof(linkedlist_datablock_internal)); + if (ldi!=NULL) + { + ldi->next_datablock = NULL ; + ldi->filled_in_this_block = 0 ; + ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; + } + return ldi; +} + +local void free_datablock(linkedlist_datablock_internal* ldi) +{ + while (ldi!=NULL) + { + linkedlist_datablock_internal* ldinext = ldi->next_datablock; + TRYFREE(ldi); + ldi = ldinext; + } +} + +local void init_linkedlist(linkedlist_data* ll) +{ + ll->first_block = ll->last_block = NULL; +} + +local void free_linkedlist(linkedlist_data* ll) +{ + free_datablock(ll->first_block); + ll->first_block = ll->last_block = NULL; +} + + +local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len) +{ + linkedlist_datablock_internal* ldi; + const unsigned char* from_copy; + + if (ll==NULL) + return ZIP_INTERNALERROR; + + if (ll->last_block == NULL) + { + ll->first_block = ll->last_block = allocate_new_datablock(); + if (ll->first_block == NULL) + return ZIP_INTERNALERROR; + } + + ldi = ll->last_block; + from_copy = (unsigned char*)buf; + + while (len>0) + { + uInt copy_this; + uInt i; + unsigned char* to_copy; + + if (ldi->avail_in_this_block==0) + { + ldi->next_datablock = allocate_new_datablock(); + if (ldi->next_datablock == NULL) + return ZIP_INTERNALERROR; + ldi = ldi->next_datablock ; + ll->last_block = ldi; + } + + if (ldi->avail_in_this_block < len) + copy_this = (uInt)ldi->avail_in_this_block; + else + copy_this = (uInt)len; + + to_copy = &(ldi->data[ldi->filled_in_this_block]); + + for (i=0;ifilled_in_this_block += copy_this; + ldi->avail_in_this_block -= copy_this; + from_copy += copy_this ; + len -= copy_this; + } + return ZIP_OK; +} + + + +/****************************************************************************/ + +#ifndef NO_ADDFILEINEXISTINGZIP +/* =========================================================================== + Inputs a long in LSB order to the given file + nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T) +*/ + +local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)); +local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte) +{ + unsigned char buf[8]; + int n; + for (n = 0; n < nbByte; n++) + { + buf[n] = (unsigned char)(x & 0xff); + x >>= 8; + } + if (x != 0) + { /* data overflow - hack for ZIP64 (X Roche) */ + for (n = 0; n < nbByte; n++) + { + buf[n] = 0xff; + } + } + + if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) + return ZIP_ERRNO; + else + return ZIP_OK; +} + +local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte)); +local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte) +{ + unsigned char* buf=(unsigned char*)dest; + int n; + for (n = 0; n < nbByte; n++) { + buf[n] = (unsigned char)(x & 0xff); + x >>= 8; + } + + if (x != 0) + { /* data overflow - hack for ZIP64 */ + for (n = 0; n < nbByte; n++) + { + buf[n] = 0xff; + } + } +} + +/****************************************************************************/ + + +local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm) +{ + uLong year = (uLong)ptm->tm_year; + if (year>=1980) + year-=1980; + else if (year>=80) + year-=80; + return + (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | + ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); +} + + +/****************************************************************************/ + +local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)); + +local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi) +{ + unsigned char c; + int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1); + if (err==1) + { + *pi = (int)c; + return ZIP_OK; + } + else + { + if (ZERROR64(*pzlib_filefunc_def,filestream)) + return ZIP_ERRNO; + else + return ZIP_EOF; + } +} + + +/* =========================================================================== + Reads a long in LSB order from the given gz_stream. Sets +*/ +local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); + +local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) +{ + uLong x ; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (uLong)i; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<8; + + if (err==ZIP_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); + +local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) +{ + uLong x ; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (uLong)i; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<8; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<16; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<24; + + if (err==ZIP_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)); + + +local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) +{ + ZPOS64_T x; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (ZPOS64_T)i; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<8; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<16; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<24; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<32; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<40; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<48; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<56; + + if (err==ZIP_OK) + *pX = x; + else + *pX = 0; + + return err; +} + +#ifndef BUFREADCOMMENT +#define BUFREADCOMMENT (0x400) +#endif +/* + Locate the Central directory of a zipfile (at the end, just before + the global comment) +*/ +local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); + +local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) +{ + unsigned char* buf; + ZPOS64_T uSizeFile; + ZPOS64_T uBackRead; + ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ + ZPOS64_T uPosFound=0; + + if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) + return 0; + + + uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream); + + if (uMaxBack>uSizeFile) + uMaxBack = uSizeFile; + + buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); + if (buf==NULL) + return 0; + + uBackRead = 4; + while (uBackReaduMaxBack) + uBackRead = uMaxBack; + else + uBackRead+=BUFREADCOMMENT; + uReadPos = uSizeFile-uBackRead ; + + uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? + (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos); + if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) + break; + + if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) + break; + + for (i=(int)uReadSize-3; (i--)>0;) + if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && + ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) + { + uPosFound = uReadPos+i; + break; + } + + if (uPosFound!=0) + break; + } + TRYFREE(buf); + return uPosFound; +} + +/* +Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before +the global comment) +*/ +local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); + +local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) +{ + unsigned char* buf; + ZPOS64_T uSizeFile; + ZPOS64_T uBackRead; + ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ + ZPOS64_T uPosFound=0; + uLong uL; + ZPOS64_T relativeOffset; + + if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) + return 0; + + uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream); + + if (uMaxBack>uSizeFile) + uMaxBack = uSizeFile; + + buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); + if (buf==NULL) + return 0; + + uBackRead = 4; + while (uBackReaduMaxBack) + uBackRead = uMaxBack; + else + uBackRead+=BUFREADCOMMENT; + uReadPos = uSizeFile-uBackRead ; + + uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? + (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos); + if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) + break; + + if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) + break; + + for (i=(int)uReadSize-3; (i--)>0;) + { + // Signature "0x07064b50" Zip64 end of central directory locater + if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07)) + { + uPosFound = uReadPos+i; + break; + } + } + + if (uPosFound!=0) + break; + } + + TRYFREE(buf); + if (uPosFound == 0) + return 0; + + /* Zip64 end of central directory locator */ + if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0) + return 0; + + /* the signature, already checked */ + if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) + return 0; + + /* number of the disk with the start of the zip64 end of central directory */ + if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) + return 0; + if (uL != 0) + return 0; + + /* relative offset of the zip64 end of central directory record */ + if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK) + return 0; + + /* total number of disks */ + if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) + return 0; + if (uL != 1) + return 0; + + /* Goto Zip64 end of central directory record */ + if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0) + return 0; + + /* the signature */ + if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) + return 0; + + if (uL != 0x06064b50) // signature of 'Zip64 end of central directory' + return 0; + + return relativeOffset; +} + +int LoadCentralDirectoryRecord(zip64_internal* pziinit) +{ + int err=ZIP_OK; + ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ + + ZPOS64_T size_central_dir; /* size of the central directory */ + ZPOS64_T offset_central_dir; /* offset of start of central directory */ + ZPOS64_T central_pos; + uLong uL; + + uLong number_disk; /* number of the current dist, used for + spaning ZIP, unsupported, always 0*/ + uLong number_disk_with_CD; /* number the the disk with central dir, used + for spaning ZIP, unsupported, always 0*/ + ZPOS64_T number_entry; + ZPOS64_T number_entry_CD; /* total number of entries in + the central dir + (same than number_entry on nospan) */ + uLong VersionMadeBy; + uLong VersionNeeded; + uLong size_comment; + + int hasZIP64Record = 0; + + // check first if we find a ZIP64 record + central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream); + if(central_pos > 0) + { + hasZIP64Record = 1; + } + else if(central_pos == 0) + { + central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream); + } + +/* disable to allow appending to empty ZIP archive + if (central_pos==0) + err=ZIP_ERRNO; +*/ + + if(hasZIP64Record) + { + ZPOS64_T sizeEndOfCentralDirectory; + if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err=ZIP_ERRNO; + + /* the signature, already checked */ + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) + err=ZIP_ERRNO; + + /* size of zip64 end of central directory record */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK) + err=ZIP_ERRNO; + + /* version made by */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK) + err=ZIP_ERRNO; + + /* version needed to extract */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK) + err=ZIP_ERRNO; + + /* number of this disk */ + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) + err=ZIP_ERRNO; + + /* number of the disk with the start of the central directory */ + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) + err=ZIP_ERRNO; + + /* total number of entries in the central directory on this disk */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK) + err=ZIP_ERRNO; + + /* total number of entries in the central directory */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK) + err=ZIP_ERRNO; + + if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) + err=ZIP_BADZIPFILE; + + /* size of the central directory */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK) + err=ZIP_ERRNO; + + /* offset of start of central directory with respect to the + starting disk number */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK) + err=ZIP_ERRNO; + + // TODO.. + // read the comment from the standard central header. + size_comment = 0; + } + else + { + // Read End of central Directory info + if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) + err=ZIP_ERRNO; + + /* the signature, already checked */ + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) + err=ZIP_ERRNO; + + /* number of this disk */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) + err=ZIP_ERRNO; + + /* number of the disk with the start of the central directory */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) + err=ZIP_ERRNO; + + /* total number of entries in the central dir on this disk */ + number_entry = 0; + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) + err=ZIP_ERRNO; + else + number_entry = uL; + + /* total number of entries in the central dir */ + number_entry_CD = 0; + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) + err=ZIP_ERRNO; + else + number_entry_CD = uL; + + if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) + err=ZIP_BADZIPFILE; + + /* size of the central directory */ + size_central_dir = 0; + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) + err=ZIP_ERRNO; + else + size_central_dir = uL; + + /* offset of start of central directory with respect to the starting disk number */ + offset_central_dir = 0; + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) + err=ZIP_ERRNO; + else + offset_central_dir = uL; + + + /* zipfile global comment length */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK) + err=ZIP_ERRNO; + } + + if ((central_posz_filefunc, pziinit->filestream); + return ZIP_ERRNO; + } + + if (size_comment>0) + { + pziinit->globalcomment = (char*)ALLOC(size_comment+1); + if (pziinit->globalcomment) + { + size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment); + pziinit->globalcomment[size_comment]=0; + } + } + + byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir); + pziinit->add_position_when_writting_offset = byte_before_the_zipfile; + + { + ZPOS64_T size_central_dir_to_read = size_central_dir; + size_t buf_size = SIZEDATA_INDATABLOCK; + void* buf_read = (void*)ALLOC(buf_size); + if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + err=ZIP_ERRNO; + + while ((size_central_dir_to_read>0) && (err==ZIP_OK)) + { + ZPOS64_T read_this = SIZEDATA_INDATABLOCK; + if (read_this > size_central_dir_to_read) + read_this = size_central_dir_to_read; + + if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this) + err=ZIP_ERRNO; + + if (err==ZIP_OK) + err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this); + + size_central_dir_to_read-=read_this; + } + TRYFREE(buf_read); + } + pziinit->begin_pos = byte_before_the_zipfile; + pziinit->number_entry = number_entry_CD; + + if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0) + err=ZIP_ERRNO; + + return err; +} + + +#endif /* !NO_ADDFILEINEXISTINGZIP*/ + + +/************************************************************/ +extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def) +{ + zip64_internal ziinit; + zip64_internal* zi; + int err=ZIP_OK; + + ziinit.z_filefunc.zseek32_file = NULL; + ziinit.z_filefunc.ztell32_file = NULL; + if (pzlib_filefunc64_32_def==NULL) + fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64); + else + ziinit.z_filefunc = *pzlib_filefunc64_32_def; + + ziinit.filestream = ZOPEN64(ziinit.z_filefunc, + pathname, + (append == APPEND_STATUS_CREATE) ? + (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : + (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); + + if (ziinit.filestream == NULL) + return NULL; + + if (append == APPEND_STATUS_CREATEAFTER) + ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END); + + ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream); + ziinit.in_opened_file_inzip = 0; + ziinit.ci.stream_initialised = 0; + ziinit.number_entry = 0; + ziinit.add_position_when_writting_offset = 0; + init_linkedlist(&(ziinit.central_dir)); + + + + zi = (zip64_internal*)ALLOC(sizeof(zip64_internal)); + if (zi==NULL) + { + ZCLOSE64(ziinit.z_filefunc,ziinit.filestream); + return NULL; + } + + /* now we add file in a zipfile */ +# ifndef NO_ADDFILEINEXISTINGZIP + ziinit.globalcomment = NULL; + if (append == APPEND_STATUS_ADDINZIP) + { + // Read and Cache Central Directory Records + err = LoadCentralDirectoryRecord(&ziinit); + } + + if (globalcomment) + { + *globalcomment = ziinit.globalcomment; + } +# endif /* !NO_ADDFILEINEXISTINGZIP*/ + + if (err != ZIP_OK) + { +# ifndef NO_ADDFILEINEXISTINGZIP + TRYFREE(ziinit.globalcomment); +# endif /* !NO_ADDFILEINEXISTINGZIP*/ + TRYFREE(zi); + return NULL; + } + else + { + *zi = ziinit; + return (zipFile)zi; + } +} + +extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def) +{ + if (pzlib_filefunc32_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def); + return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); + } + else + return zipOpen3(pathname, append, globalcomment, NULL); +} + +extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def) +{ + if (pzlib_filefunc_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); + } + else + return zipOpen3(pathname, append, globalcomment, NULL); +} + + + +extern zipFile ZEXPORT zipOpen (const char* pathname, int append) +{ + return zipOpen3((const void*)pathname,append,NULL,NULL); +} + +extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append) +{ + return zipOpen3(pathname,append,NULL,NULL); +} + +int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local) +{ + /* write the local header */ + int err; + uInt size_filename = (uInt)strlen(filename); + uInt size_extrafield = size_extrafield_local; + + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4); + + if (err==ZIP_OK) + { + if(zi->ci.zip64) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */ + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ + } + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); + + // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ + if (err==ZIP_OK) + { + if(zi->ci.zip64) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */ + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ + } + if (err==ZIP_OK) + { + if(zi->ci.zip64) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */ + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ + } + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); + + if(zi->ci.zip64) + { + size_extrafield += 20; + } + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2); + + if ((err==ZIP_OK) && (size_filename > 0)) + { + if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) + err = ZIP_ERRNO; + } + + if ((err==ZIP_OK) && (size_extrafield_local > 0)) + { + if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local) + err = ZIP_ERRNO; + } + + + if ((err==ZIP_OK) && (zi->ci.zip64)) + { + // write the Zip64 extended info + short HeaderID = 1; + short DataSize = 16; + ZPOS64_T CompressedSize = 0; + ZPOS64_T UncompressedSize = 0; + + // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file) + zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream); + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2); + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8); + } + + return err; +} + +/* + NOTE. + When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped + before calling this function it can be done with zipRemoveExtraInfoBlock + + It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize + unnecessary allocations. + */ +extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void* extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level, int raw, + int windowBits,int memLevel, int strategy, + const char* password, uLong crcForCrypting, + uLong versionMadeBy, uLong flagBase, int zip64) +{ + zip64_internal* zi; + uInt size_filename; + uInt size_comment; + uInt i; + int err = ZIP_OK; + +# ifdef NOCRYPT + (crcForCrypting); + if (password != NULL) + return ZIP_PARAMERROR; +# endif + + if (file == NULL) + return ZIP_PARAMERROR; + +#ifdef HAVE_BZIP2 + if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED)) + return ZIP_PARAMERROR; +#else + if ((method!=0) && (method!=Z_DEFLATED)) + return ZIP_PARAMERROR; +#endif + + zi = (zip64_internal*)file; + + if (zi->in_opened_file_inzip == 1) + { + err = zipCloseFileInZip (file); + if (err != ZIP_OK) + return err; + } + + if (filename==NULL) + filename="-"; + + if (comment==NULL) + size_comment = 0; + else + size_comment = (uInt)strlen(comment); + + size_filename = (uInt)strlen(filename); + + if (zipfi == NULL) + zi->ci.dosDate = 0; + else + { + if (zipfi->dosDate != 0) + zi->ci.dosDate = zipfi->dosDate; + else + zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date); + } + + zi->ci.flag = flagBase; + if ((level==8) || (level==9)) + zi->ci.flag |= 2; + if (level==2) + zi->ci.flag |= 4; + if (level==1) + zi->ci.flag |= 6; + if (password != NULL) + zi->ci.flag |= 1; + + zi->ci.crc32 = 0; + zi->ci.method = method; + zi->ci.encrypt = 0; + zi->ci.stream_initialised = 0; + zi->ci.pos_in_buffered_data = 0; + zi->ci.raw = raw; + zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream); + + zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment; + zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data + + zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree); + + zi->ci.size_centralExtra = size_extrafield_global; + zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); + /* version info */ + zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2); + zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); + zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); + zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); + zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); + zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ + zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ + zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ + zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); + zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); + zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); + zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ + + if (zipfi==NULL) + zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); + else + zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); + + if (zipfi==NULL) + zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); + else + zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); + + if(zi->ci.pos_local_header >= 0xffffffff) + zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4); + else + zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset,4); + + for (i=0;ici.central_header+SIZECENTRALHEADER+i) = *(filename+i); + + for (i=0;ici.central_header+SIZECENTRALHEADER+size_filename+i) = + *(((const char*)extrafield_global)+i); + + for (i=0;ici.central_header+SIZECENTRALHEADER+size_filename+ + size_extrafield_global+i) = *(comment+i); + if (zi->ci.central_header == NULL) + return ZIP_INTERNALERROR; + + zi->ci.zip64 = zip64; + zi->ci.totalCompressedData = 0; + zi->ci.totalUncompressedData = 0; + zi->ci.pos_zip64extrainfo = 0; + + err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local); + +#ifdef HAVE_BZIP2 + zi->ci.bstream.avail_in = (uInt)0; + zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; + zi->ci.bstream.total_in_hi32 = 0; + zi->ci.bstream.total_in_lo32 = 0; + zi->ci.bstream.total_out_hi32 = 0; + zi->ci.bstream.total_out_lo32 = 0; +#endif + + zi->ci.stream.avail_in = (uInt)0; + zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.stream.next_out = zi->ci.buffered_data; + zi->ci.stream.total_in = 0; + zi->ci.stream.total_out = 0; + zi->ci.stream.data_type = Z_BINARY; + +#ifdef HAVE_BZIP2 + if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) +#else + if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) +#endif + { + if(zi->ci.method == Z_DEFLATED) + { + zi->ci.stream.zalloc = (alloc_func)0; + zi->ci.stream.zfree = (free_func)0; + zi->ci.stream.opaque = (voidpf)0; + + if (windowBits>0) + windowBits = -windowBits; + + err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy); + + if (err==Z_OK) + zi->ci.stream_initialised = Z_DEFLATED; + } + else if(zi->ci.method == Z_BZIP2ED) + { +#ifdef HAVE_BZIP2 + // Init BZip stuff here + zi->ci.bstream.bzalloc = 0; + zi->ci.bstream.bzfree = 0; + zi->ci.bstream.opaque = (voidpf)0; + + err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35); + if(err == BZ_OK) + zi->ci.stream_initialised = Z_BZIP2ED; +#endif + } + + } + +# ifndef NOCRYPT + zi->ci.crypt_header_size = 0; + if ((err==Z_OK) && (password != NULL)) + { + unsigned char bufHead[RAND_HEAD_LEN]; + unsigned int sizeHead; + zi->ci.encrypt = 1; + zi->ci.pcrc_32_tab = get_crc_table(); + /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ + + sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); + zi->ci.crypt_header_size = sizeHead; + + if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) + err = ZIP_ERRNO; + } +# endif + + if (err==Z_OK) + zi->in_opened_file_inzip = 1; + return err; +} + +extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void* extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level, int raw, + int windowBits,int memLevel, int strategy, + const char* password, uLong crcForCrypting, + uLong versionMadeBy, uLong flagBase) +{ + return zipOpenNewFileInZip4_64 (file, filename, zipfi, + extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, + comment, method, level, raw, + windowBits, memLevel, strategy, + password, crcForCrypting, versionMadeBy, flagBase, 0); +} + +extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void* extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level, int raw, + int windowBits,int memLevel, int strategy, + const char* password, uLong crcForCrypting) +{ + return zipOpenNewFileInZip4_64 (file, filename, zipfi, + extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, + comment, method, level, raw, + windowBits, memLevel, strategy, + password, crcForCrypting, VERSIONMADEBY, 0, 0); +} + +extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void* extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level, int raw, + int windowBits,int memLevel, int strategy, + const char* password, uLong crcForCrypting, int zip64) +{ + return zipOpenNewFileInZip4_64 (file, filename, zipfi, + extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, + comment, method, level, raw, + windowBits, memLevel, strategy, + password, crcForCrypting, VERSIONMADEBY, 0, zip64); +} + +extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void* extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level, int raw) +{ + return zipOpenNewFileInZip4_64 (file, filename, zipfi, + extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, + comment, method, level, raw, + -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, + NULL, 0, VERSIONMADEBY, 0, 0); +} + +extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void* extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level, int raw, int zip64) +{ + return zipOpenNewFileInZip4_64 (file, filename, zipfi, + extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, + comment, method, level, raw, + -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, + NULL, 0, VERSIONMADEBY, 0, zip64); +} + +extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void*extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level, int zip64) +{ + return zipOpenNewFileInZip4_64 (file, filename, zipfi, + extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, + comment, method, level, 0, + -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, + NULL, 0, VERSIONMADEBY, 0, zip64); +} + +extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void*extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level) +{ + return zipOpenNewFileInZip4_64 (file, filename, zipfi, + extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, + comment, method, level, 0, + -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, + NULL, 0, VERSIONMADEBY, 0, 0); +} + +local int zip64FlushWriteBuffer(zip64_internal* zi) +{ + int err=ZIP_OK; + + if (zi->ci.encrypt != 0) + { +#ifndef NOCRYPT + uInt i; + int t; + for (i=0;ici.pos_in_buffered_data;i++) + zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t); +#endif + } + + if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data) + err = ZIP_ERRNO; + + zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data; + +#ifdef HAVE_BZIP2 + if(zi->ci.method == Z_BZIP2ED) + { + zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32; + zi->ci.bstream.total_in_lo32 = 0; + zi->ci.bstream.total_in_hi32 = 0; + } + else +#endif + { + zi->ci.totalUncompressedData += zi->ci.stream.total_in; + zi->ci.stream.total_in = 0; + } + + + zi->ci.pos_in_buffered_data = 0; + + return err; +} + +extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len) +{ + zip64_internal* zi; + int err=ZIP_OK; + + if (file == NULL) + return ZIP_PARAMERROR; + zi = (zip64_internal*)file; + + if (zi->in_opened_file_inzip == 0) + return ZIP_PARAMERROR; + + zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len); + +#ifdef HAVE_BZIP2 + if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw)) + { + zi->ci.bstream.next_in = (void*)buf; + zi->ci.bstream.avail_in = len; + err = BZ_RUN_OK; + + while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0)) + { + if (zi->ci.bstream.avail_out == 0) + { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; + } + + + if(err != BZ_RUN_OK) + break; + + if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) + { + uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32; +// uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32; + err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN); + + zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ; + } + } + + if(err == BZ_RUN_OK) + err = ZIP_OK; + } + else +#endif + { + zi->ci.stream.next_in = (Bytef*)buf; + zi->ci.stream.avail_in = len; + + while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) + { + if (zi->ci.stream.avail_out == 0) + { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.stream.next_out = zi->ci.buffered_data; + } + + + if(err != ZIP_OK) + break; + + if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) + { + uLong uTotalOutBefore = zi->ci.stream.total_out; + err=deflate(&zi->ci.stream, Z_NO_FLUSH); + if(uTotalOutBefore > zi->ci.stream.total_out) + { + int bBreak = 0; + bBreak++; + } + + zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; + } + else + { + uInt copy_this,i; + if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) + copy_this = zi->ci.stream.avail_in; + else + copy_this = zi->ci.stream.avail_out; + + for (i = 0; i < copy_this; i++) + *(((char*)zi->ci.stream.next_out)+i) = + *(((const char*)zi->ci.stream.next_in)+i); + { + zi->ci.stream.avail_in -= copy_this; + zi->ci.stream.avail_out-= copy_this; + zi->ci.stream.next_in+= copy_this; + zi->ci.stream.next_out+= copy_this; + zi->ci.stream.total_in+= copy_this; + zi->ci.stream.total_out+= copy_this; + zi->ci.pos_in_buffered_data += copy_this; + } + } + }// while(...) + } + + return err; +} + +extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32) +{ + return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32); +} + +extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32) +{ + zip64_internal* zi; + ZPOS64_T compressed_size; + uLong invalidValue = 0xffffffff; + short datasize = 0; + int err=ZIP_OK; + + if (file == NULL) + return ZIP_PARAMERROR; + zi = (zip64_internal*)file; + + if (zi->in_opened_file_inzip == 0) + return ZIP_PARAMERROR; + zi->ci.stream.avail_in = 0; + + if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) + { + while (err==ZIP_OK) + { + uLong uTotalOutBefore; + if (zi->ci.stream.avail_out == 0) + { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.stream.next_out = zi->ci.buffered_data; + } + uTotalOutBefore = zi->ci.stream.total_out; + err=deflate(&zi->ci.stream, Z_FINISH); + zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; + } + } + else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) + { +#ifdef HAVE_BZIP2 + err = BZ_FINISH_OK; + while (err==BZ_FINISH_OK) + { + uLong uTotalOutBefore; + if (zi->ci.bstream.avail_out == 0) + { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; + } + uTotalOutBefore = zi->ci.bstream.total_out_lo32; + err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH); + if(err == BZ_STREAM_END) + err = Z_STREAM_END; + + zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore); + } + + if(err == BZ_FINISH_OK) + err = ZIP_OK; +#endif + } + + if (err==Z_STREAM_END) + err=ZIP_OK; /* this is normal */ + + if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) + { + if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO) + err = ZIP_ERRNO; + } + + if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) + { + int tmp_err = deflateEnd(&zi->ci.stream); + if (err == ZIP_OK) + err = tmp_err; + zi->ci.stream_initialised = 0; + } +#ifdef HAVE_BZIP2 + else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) + { + int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream); + if (err==ZIP_OK) + err = tmperr; + zi->ci.stream_initialised = 0; + } +#endif + + if (!zi->ci.raw) + { + crc32 = (uLong)zi->ci.crc32; + uncompressed_size = zi->ci.totalUncompressedData; + } + compressed_size = zi->ci.totalCompressedData; + +# ifndef NOCRYPT + compressed_size += zi->ci.crypt_header_size; +# endif + + // update Current Item crc and sizes, + if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff) + { + /*version Made by*/ + zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2); + /*version needed*/ + zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2); + + } + + zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ + + + if(compressed_size >= 0xffffffff) + zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/ + else + zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/ + + /// set internal file attributes field + if (zi->ci.stream.data_type == Z_ASCII) + zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); + + if(uncompressed_size >= 0xffffffff) + zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/ + else + zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/ + + // Add ZIP64 extra info field for uncompressed size + if(uncompressed_size >= 0xffffffff) + datasize += 8; + + // Add ZIP64 extra info field for compressed size + if(compressed_size >= 0xffffffff) + datasize += 8; + + // Add ZIP64 extra info field for relative offset to local file header of current file + if(zi->ci.pos_local_header >= 0xffffffff) + datasize += 8; + + if(datasize > 0) + { + char* p = NULL; + + if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree) + { + // we can not write more data to the buffer that we have room for. + return ZIP_BADZIPFILE; + } + + p = zi->ci.central_header + zi->ci.size_centralheader; + + // Add Extra Information Header for 'ZIP64 information' + zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID + p += 2; + zip64local_putValue_inmemory(p, datasize, 2); // DataSize + p += 2; + + if(uncompressed_size >= 0xffffffff) + { + zip64local_putValue_inmemory(p, uncompressed_size, 8); + p += 8; + } + + if(compressed_size >= 0xffffffff) + { + zip64local_putValue_inmemory(p, compressed_size, 8); + p += 8; + } + + if(zi->ci.pos_local_header >= 0xffffffff) + { + zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8); + p += 8; + } + + // Update how much extra free space we got in the memory buffer + // and increase the centralheader size so the new ZIP64 fields are included + // ( 4 below is the size of HeaderID and DataSize field ) + zi->ci.size_centralExtraFree -= datasize + 4; + zi->ci.size_centralheader += datasize + 4; + + // Update the extra info size field + zi->ci.size_centralExtra += datasize + 4; + zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2); + } + + if (err==ZIP_OK) + err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader); + + free(zi->ci.central_header); + + if (err==ZIP_OK) + { + // Update the LocalFileHeader with the new values. + + ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream); + + if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) + err = ZIP_ERRNO; + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ + + if(uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff ) + { + if(zi->ci.pos_zip64extrainfo > 0) + { + // Update the size in the ZIP64 extended field. + if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0) + err = ZIP_ERRNO; + + if (err==ZIP_OK) /* compressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8); + + if (err==ZIP_OK) /* uncompressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8); + } + else + err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal + } + else + { + if (err==ZIP_OK) /* compressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); + + if (err==ZIP_OK) /* uncompressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); + } + + if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) + err = ZIP_ERRNO; + } + + zi->number_entry ++; + zi->in_opened_file_inzip = 0; + + return err; +} + +extern int ZEXPORT zipCloseFileInZip (zipFile file) +{ + return zipCloseFileInZipRaw (file,0,0); +} + +int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip) +{ + int err = ZIP_OK; + ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset; + + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4); + + /*num disks*/ + if (err==ZIP_OK) /* number of the disk with the start of the central directory */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); + + /*relative offset*/ + if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8); + + /*total disks*/ /* Do not support spawning of disk so always say 1 here*/ + if (err==ZIP_OK) /* number of the disk with the start of the central directory */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4); + + return err; +} + +int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) +{ + int err = ZIP_OK; + + uLong Zip64DataSize = 44; + + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4); + + if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ? + + if (err==ZIP_OK) /* version made by */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2); + + if (err==ZIP_OK) /* version needed */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2); + + if (err==ZIP_OK) /* number of this disk */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); + + if (err==ZIP_OK) /* number of the disk with the start of the central directory */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); + + if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); + + if (err==ZIP_OK) /* total number of entries in the central dir */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); + + if (err==ZIP_OK) /* size of the central directory */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8); + + if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */ + { + ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; + err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8); + } + return err; +} +int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) +{ + int err = ZIP_OK; + + /*signature*/ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); + + if (err==ZIP_OK) /* number of this disk */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); + + if (err==ZIP_OK) /* number of the disk with the start of the central directory */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); + + if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ + { + { + if(zi->number_entry >= 0xFFFF) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); + } + } + + if (err==ZIP_OK) /* total number of entries in the central dir */ + { + if(zi->number_entry >= 0xFFFF) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); + } + + if (err==ZIP_OK) /* size of the central directory */ + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); + + if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */ + { + ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; + if(pos >= 0xffffffff) + { + err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4); + } + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); + } + + return err; +} + +int Write_GlobalComment(zip64_internal* zi, const char* global_comment) +{ + int err = ZIP_OK; + uInt size_global_comment = 0; + + if(global_comment != NULL) + size_global_comment = (uInt)strlen(global_comment); + + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); + + if (err == ZIP_OK && size_global_comment > 0) + { + if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment) + err = ZIP_ERRNO; + } + return err; +} + +extern int ZEXPORT zipClose (zipFile file, const char* global_comment) +{ + zip64_internal* zi; + int err = 0; + uLong size_centraldir = 0; + ZPOS64_T centraldir_pos_inzip; + ZPOS64_T pos; + + if (file == NULL) + return ZIP_PARAMERROR; + + zi = (zip64_internal*)file; + + if (zi->in_opened_file_inzip == 1) + { + err = zipCloseFileInZip (file); + } + +#ifndef NO_ADDFILEINEXISTINGZIP + if (global_comment==NULL) + global_comment = zi->globalcomment; +#endif + + centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream); + + if (err==ZIP_OK) + { + linkedlist_datablock_internal* ldi = zi->central_dir.first_block; + while (ldi!=NULL) + { + if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) + { + if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block) + err = ZIP_ERRNO; + } + + size_centraldir += ldi->filled_in_this_block; + ldi = ldi->next_datablock; + } + } + free_linkedlist(&(zi->central_dir)); + + pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; + if(pos >= 0xffffffff || zi->number_entry > 0xFFFF) + { + ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream); + Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); + + Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos); + } + + if (err==ZIP_OK) + err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); + + if(err == ZIP_OK) + err = Write_GlobalComment(zi, global_comment); + + if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0) + if (err == ZIP_OK) + err = ZIP_ERRNO; + +#ifndef NO_ADDFILEINEXISTINGZIP + TRYFREE(zi->globalcomment); +#endif + TRYFREE(zi); + + return err; +} + +extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader) +{ + char* p = pData; + int size = 0; + char* pNewHeader; + char* pTmp; + short header; + short dataSize; + + int retVal = ZIP_OK; + + if(pData == NULL || *dataLen < 4) + return ZIP_PARAMERROR; + + pNewHeader = (char*)ALLOC(*dataLen); + pTmp = pNewHeader; + + while(p < (pData + *dataLen)) + { + header = *(short*)p; + dataSize = *(((short*)p)+1); + + if( header == sHeader ) // Header found. + { + p += dataSize + 4; // skip it. do not copy to temp buffer + } + else + { + // Extra Info block should not be removed, So copy it to the temp buffer. + memcpy(pTmp, p, dataSize + 4); + p += dataSize + 4; + size += dataSize + 4; + } + + } + + if(size < *dataLen) + { + // clean old extra info block. + memset(pData,0, *dataLen); + + // copy the new extra info block over the old + if(size > 0) + memcpy(pData, pNewHeader, size); + + // set the new extra info size + *dataLen = size; + + retVal = ZIP_OK; + } + else + retVal = ZIP_ERRNO; + + TRYFREE(pNewHeader); + + return retVal; +} diff --git a/Telegram/SourceFiles/_other/zip.h b/Telegram/SourceFiles/_other/zip.h new file mode 100644 index 000000000..8aaebb623 --- /dev/null +++ b/Telegram/SourceFiles/_other/zip.h @@ -0,0 +1,362 @@ +/* zip.h -- IO on .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + + --------------------------------------------------------------------------- + + Condition of use and distribution are the same than zlib : + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + --------------------------------------------------------------------------- + + Changes + + See header of zip.h + +*/ + +#ifndef _zip12_H +#define _zip12_H + +#ifdef __cplusplus +extern "C" { +#endif + +//#define HAVE_BZIP2 + +#ifndef _ZLIB_H +#include "zlib.h" +#endif + +#ifndef _ZLIBIOAPI_H +#include "ioapi.h" +#endif + +#ifdef HAVE_BZIP2 +#include "bzlib.h" +#endif + +#define Z_BZIP2ED 12 + +#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) +/* like the STRICT of WIN32, we define a pointer that cannot be converted + from (void*) without cast */ +typedef struct TagzipFile__ { int unused; } zipFile__; +typedef zipFile__ *zipFile; +#else +typedef voidp zipFile; +#endif + +#define ZIP_OK (0) +#define ZIP_EOF (0) +#define ZIP_ERRNO (Z_ERRNO) +#define ZIP_PARAMERROR (-102) +#define ZIP_BADZIPFILE (-103) +#define ZIP_INTERNALERROR (-104) + +#ifndef DEF_MEM_LEVEL +# if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +# else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +# endif +#endif +/* default memLevel */ + +/* tm_zip contain date/time info */ +typedef struct tm_zip_s +{ + uInt tm_sec; /* seconds after the minute - [0,59] */ + uInt tm_min; /* minutes after the hour - [0,59] */ + uInt tm_hour; /* hours since midnight - [0,23] */ + uInt tm_mday; /* day of the month - [1,31] */ + uInt tm_mon; /* months since January - [0,11] */ + uInt tm_year; /* years - [1980..2044] */ +} tm_zip; + +typedef struct +{ + tm_zip tmz_date; /* date in understandable format */ + uLong dosDate; /* if dos_date == 0, tmu_date is used */ +/* uLong flag; */ /* general purpose bit flag 2 bytes */ + + uLong internal_fa; /* internal file attributes 2 bytes */ + uLong external_fa; /* external file attributes 4 bytes */ +} zip_fileinfo; + +typedef const char* zipcharpc; + + +#define APPEND_STATUS_CREATE (0) +#define APPEND_STATUS_CREATEAFTER (1) +#define APPEND_STATUS_ADDINZIP (2) + +extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); +extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append)); +/* + Create a zipfile. + pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on + an Unix computer "zlib/zlib113.zip". + if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip + will be created at the end of the file. + (useful if the file contain a self extractor code) + if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will + add files in existing zip (be sure you don't add file that doesn't exist) + If the zipfile cannot be opened, the return value is NULL. + Else, the return value is a zipFile Handle, usable with other function + of this zip package. +*/ + +/* Note : there is no delete function into a zipfile. + If you want delete file into a zipfile, you must open a zipfile, and create another + Of couse, you can use RAW reading and writing to copy the file you did not want delte +*/ + +extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, + int append, + zipcharpc* globalcomment, + zlib_filefunc_def* pzlib_filefunc_def)); + +extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname, + int append, + zipcharpc* globalcomment, + zlib_filefunc64_def* pzlib_filefunc_def)); + +extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level)); + +extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int zip64)); + +/* + Open a file in the ZIP for writing. + filename : the filename in zip (if NULL, '-' without quote will be used + *zipfi contain supplemental information + if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local + contains the extrafield data the the local header + if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global + contains the extrafield data the the local header + if comment != NULL, comment contain the comment string + method contain the compression method (0 for store, Z_DEFLATED for deflate) + level contain the level of compression (can be Z_DEFAULT_COMPRESSION) + zip64 is set to 1 if a zip64 extended information block should be added to the local file header. + this MUST be '1' if the uncompressed size is >= 0xffffffff. + +*/ + + +extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int raw)); + + +extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int raw, + int zip64)); +/* + Same than zipOpenNewFileInZip, except if raw=1, we write raw file + */ + +extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int raw, + int windowBits, + int memLevel, + int strategy, + const char* password, + uLong crcForCrypting)); + +extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int raw, + int windowBits, + int memLevel, + int strategy, + const char* password, + uLong crcForCrypting, + int zip64 + )); + +/* + Same than zipOpenNewFileInZip2, except + windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 + password : crypting password (NULL for no crypting) + crcForCrypting : crc of file to compress (needed for crypting) + */ + +extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int raw, + int windowBits, + int memLevel, + int strategy, + const char* password, + uLong crcForCrypting, + uLong versionMadeBy, + uLong flagBase + )); + + +extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int raw, + int windowBits, + int memLevel, + int strategy, + const char* password, + uLong crcForCrypting, + uLong versionMadeBy, + uLong flagBase, + int zip64 + )); +/* + Same than zipOpenNewFileInZip4, except + versionMadeBy : value for Version made by field + flag : value for flag field (compression level info will be added) + */ + + +extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, + const void* buf, + unsigned len)); +/* + Write data in the zipfile +*/ + +extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); +/* + Close the current file in the zipfile +*/ + +extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, + uLong uncompressed_size, + uLong crc32)); + +extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file, + ZPOS64_T uncompressed_size, + uLong crc32)); + +/* + Close the current file in the zipfile, for file opened with + parameter raw=1 in zipOpenNewFileInZip2 + uncompressed_size and crc32 are value for the uncompressed size +*/ + +extern int ZEXPORT zipClose OF((zipFile file, + const char* global_comment)); +/* + Close the zipfile +*/ + + +extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader)); +/* + zipRemoveExtraInfoBlock - Added by Mathias Svensson + + Remove extra information block from a extra information data for the local file header or central directory header + + It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode. + + 0x0001 is the signature header for the ZIP64 extra information blocks + + usage. + Remove ZIP64 Extra information from a central director extra field data + zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001); + + Remove ZIP64 Extra information from a Local File Header extra field data + zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001); +*/ + +#ifdef __cplusplus +} +#endif + +#endif /* _zip64_H */ diff --git a/Telegram/SourceFiles/app.cpp b/Telegram/SourceFiles/app.cpp index e12b643c2..3a992e706 100644 --- a/Telegram/SourceFiles/app.cpp +++ b/Telegram/SourceFiles/app.cpp @@ -2610,9 +2610,14 @@ namespace App { } QNetworkProxy getHttpProxySettings() { - if (cConnectionType() == dbictHttpProxy) { - const ConnectionProxy &p(cConnectionProxy()); - return QNetworkProxy(QNetworkProxy::HttpProxy, p.host, p.port, p.user, p.password); + const ConnectionProxy *proxy = 0; + if (Sandbox::started()) { + proxy = (cConnectionType() == dbictHttpProxy) ? (&cConnectionProxy()) : 0; + } else { + proxy = Global::PreLaunchProxy().host.isEmpty() ? 0 : (&Global::PreLaunchProxy()); + } + if (proxy) { + return QNetworkProxy(QNetworkProxy::HttpProxy, proxy->host, proxy->port, proxy->user, proxy->password); } return QNetworkProxy(QNetworkProxy::DefaultProxy); } diff --git a/Telegram/SourceFiles/application.cpp b/Telegram/SourceFiles/application.cpp index 49baf5714..6149620a9 100644 --- a/Telegram/SourceFiles/application.cpp +++ b/Telegram/SourceFiles/application.cpp @@ -311,7 +311,7 @@ void Application::readClients() { for (int32 to = cmds.indexOf(QChar(';'), from); to >= from; to = (from < l) ? cmds.indexOf(QChar(';'), from) : -1) { QStringRef cmd(&cmds, from, to - from); if (cmd.startsWith(qsl("CMD:"))) { - App::app()->execExternal(cmds.mid(from + 4, to - from - 4)); + Sandboxer::execExternal(cmds.mid(from + 4, to - from - 4)); QByteArray response(qsl("RES:%1;").arg(QCoreApplication::applicationPid()).toLatin1()); i->first->write(response.data(), response.size()); } else if (cmd.startsWith(qsl("SEND:"))) { @@ -485,7 +485,7 @@ void Application::startUpdateCheck(bool forceWait) { if (_updateThread || _updateReply || !cAutoUpdate()) return; int32 constDelay = cBetaVersion() ? 600 : UpdateDelayConstPart, randDelay = cBetaVersion() ? 300 : UpdateDelayRandPart; - int32 updateInSecs = cLastUpdateCheck() + constDelay + int32(MTP::nonce() % randDelay) - unixtime(); + int32 updateInSecs = cLastUpdateCheck() + constDelay + int32(rand() % randDelay) - unixtime(); bool sendRequest = (updateInSecs <= 0 || updateInSecs > (constDelay + randDelay)); if (!sendRequest && !forceWait) { QDir updates(cWorkingDir() + "tupdates"); @@ -564,6 +564,17 @@ namespace Sandboxer { return false; } + void execExternal(const QString &cmd) { + DEBUG_LOG(("Application Info: executing external command '%1'").arg(cmd)); + if (cmd == "show") { + if (App::wnd()) { + App::wnd()->activate(); + } else if (PreLaunchWindow::instance()) { + PreLaunchWindow::instance()->activate(); + } + } + } + #ifndef TDESKTOP_DISABLE_AUTOUPDATE void startUpdateCheck() { @@ -643,6 +654,8 @@ AppClass::AppClass() : QObject() , _uploader(0) { AppObject = this; + Fonts::start(); + ThirdParty::start(); Sandbox::start(); Local::start(); @@ -658,10 +671,6 @@ AppClass::AppClass() : QObject() application()->installEventFilter(new EventFilterForKeys(this)); - QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Regular.ttf")); - QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Bold.ttf")); - QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Semibold.ttf")); - float64 dpi = QApplication::primaryScreen()->logicalDotsPerInch(); if (dpi <= 108) { // 0-96-108 cSetScreenScale(dbisOne); @@ -1030,13 +1039,6 @@ void AppClass::checkMapVersion() { } } -void AppClass::execExternal(const QString &cmd) { - DEBUG_LOG(("Application Info: executing external command '%1'").arg(cmd)); - if (cmd == "show") { - _window.activate(); - } -} - AppClass::~AppClass() { _window.setParent(0); anim::stopManager(); diff --git a/Telegram/SourceFiles/application.h b/Telegram/SourceFiles/application.h index f1671f2dd..940f83819 100644 --- a/Telegram/SourceFiles/application.h +++ b/Telegram/SourceFiles/application.h @@ -113,6 +113,8 @@ namespace Sandboxer { void setActiveWindow(QWidget *window); bool isSavingSession(); + void execExternal(const QString &cmd); + #ifndef TDESKTOP_DISABLE_AUTOUPDATE void startUpdateCheck(); @@ -174,8 +176,6 @@ public: void checkLocalTime(); void checkMapVersion(); - void execExternal(const QString &cmd); - signals: void peerPhotoDone(PeerId peer); diff --git a/Telegram/SourceFiles/dropdown.cpp b/Telegram/SourceFiles/dropdown.cpp index 2ee10cd55..129ec45cc 100644 --- a/Telegram/SourceFiles/dropdown.cpp +++ b/Telegram/SourceFiles/dropdown.cpp @@ -4320,7 +4320,7 @@ void MentionsDropdown::updateFiltered(bool resetScroll) { if (it->emoji.isEmpty()) { setsToRequest.insert(it->id, it->access); it->flags |= MTPDstickerSet_flag_NOT_LOADED; - } else { + } else if (!(it->flags & MTPDstickerSet::flag_disabled)) { StickersByEmojiMap::const_iterator i = it->emoji.constFind(emojiGetNoColor(_emoji)); if (i != it->emoji.cend()) { srows += *i; diff --git a/Telegram/SourceFiles/facades.cpp b/Telegram/SourceFiles/facades.cpp index 2c3fd675f..5023c7ed7 100644 --- a/Telegram/SourceFiles/facades.cpp +++ b/Telegram/SourceFiles/facades.cpp @@ -181,6 +181,7 @@ struct GlobalDataStruct { int32 LangSystem = languageDefault; QByteArray LastCrashDump; + ConnectionProxy PreLaunchProxy; }; GlobalDataStruct *GlobalData = 0; @@ -257,6 +258,8 @@ namespace Global { break; } } + + srand((int32)time(NULL)); } void finish() { @@ -281,6 +284,7 @@ Type &Ref##Name() { \ DefineGlobalReadOnly(QString, LangSystemISO); DefineGlobalReadOnly(int32, LangSystem); DefineGlobal(QByteArray, LastCrashDump); + DefineGlobal(ConnectionProxy, PreLaunchProxy); } @@ -291,6 +295,10 @@ SandboxDataStruct *SandboxData = 0; namespace Sandbox { + bool started() { + return SandboxData != 0; + } + void start() { SandboxData = new SandboxDataStruct(); diff --git a/Telegram/SourceFiles/facades.h b/Telegram/SourceFiles/facades.h index e86c125d9..9797a95f3 100644 --- a/Telegram/SourceFiles/facades.h +++ b/Telegram/SourceFiles/facades.h @@ -112,11 +112,13 @@ namespace Global { DeclareGlobalReadOnly(QString, LangSystemISO); DeclareGlobalReadOnly(int32, LangSystem); DeclareGlobal(QByteArray, LastCrashDump); + DeclareGlobal(ConnectionProxy, PreLaunchProxy); } namespace Sandbox { + bool started(); void start(); void finish(); diff --git a/Telegram/SourceFiles/gui/images.cpp b/Telegram/SourceFiles/gui/images.cpp index 6437abf3f..7f97ef7d4 100644 --- a/Telegram/SourceFiles/gui/images.cpp +++ b/Telegram/SourceFiles/gui/images.cpp @@ -787,11 +787,11 @@ StorageImage::StorageImage(const StorageImageLocation &location, QByteArray &byt } } -int32 StorageImage::width() const { +int32 StorageImage::countWidth() const { return _location.width(); } -int32 StorageImage::height() const { +int32 StorageImage::countHeight() const { return _location.height(); } @@ -917,11 +917,11 @@ StorageImage *getImage(const StorageImageLocation &location, const QByteArray &b WebImage::WebImage(const QString &url) : _url(url), _size(0), _width(0), _height(0) { } -int32 WebImage::width() const { +int32 WebImage::countWidth() const { return _width; } -int32 WebImage::height() const { +int32 WebImage::countHeight() const { return _height; } diff --git a/Telegram/SourceFiles/gui/images.h b/Telegram/SourceFiles/gui/images.h index 5ef9d9328..a79890f5c 100644 --- a/Telegram/SourceFiles/gui/images.h +++ b/Telegram/SourceFiles/gui/images.h @@ -154,14 +154,12 @@ public: QPixmap pixColoredNoCache(const style::color &add, int32 w = 0, int32 h = 0, bool smooth = false) const; QPixmap pixBlurredColoredNoCache(const style::color &add, int32 w, int32 h = 0) const; - virtual int32 width() const { - restore(); - return _data.width(); + int32 width() const { + return qMax(countWidth(), 1); } - virtual int32 height() const { - restore(); - return _data.height(); + int32 height() const { + return qMax(countHeight(), 1); } virtual void load(bool loadFirst = false, bool prior = true) { @@ -203,6 +201,16 @@ protected: } void invalidateSizeCache() const; + virtual int32 countWidth() const { + restore(); + return _data.width(); + } + + virtual int32 countHeight() const { + restore(); + return _data.height(); + } + mutable QByteArray _saved, _format; mutable bool _forgot; mutable QPixmap _data; @@ -283,9 +291,6 @@ public: StorageImage(const StorageImageLocation &location, int32 size = 0); StorageImage(const StorageImageLocation &location, QByteArray &bytes); - int32 width() const; - int32 height() const; - virtual void setInformation(int32 size, int32 width, int32 height); virtual FileLoader *createLoader(LoadFromCloudSetting fromCloud, bool autoLoading); @@ -297,6 +302,9 @@ protected: StorageImageLocation _location; int32 _size; + virtual int32 countWidth() const; + virtual int32 countHeight() const; + }; class DelayedStorageImage : public StorageImage { @@ -341,12 +349,14 @@ public: WebImage(const QString &url); - int32 width() const; - int32 height() const; - virtual void setInformation(int32 size, int32 width, int32 height); virtual FileLoader *createLoader(LoadFromCloudSetting fromCloud, bool autoLoading); +protected: + + virtual int32 countWidth() const; + virtual int32 countHeight() const; + private: QString _url; int32 _size, _width, _height; diff --git a/Telegram/SourceFiles/gui/twidget.cpp b/Telegram/SourceFiles/gui/twidget.cpp index edd21afcd..8606aece7 100644 --- a/Telegram/SourceFiles/gui/twidget.cpp +++ b/Telegram/SourceFiles/gui/twidget.cpp @@ -22,6 +22,21 @@ Copyright (c) 2014-2015 John Preston, https://desktop.telegram.org #include "application.h" +namespace Fonts { + + bool Started = false; + void start() { + if (!Started) { + Started = true; + + QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Regular.ttf")); + QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Bold.ttf")); + QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Semibold.ttf")); + } + } + +} + namespace { void _sendResizeEvents(QWidget *target) { QResizeEvent e(target->size(), QSize()); @@ -44,7 +59,7 @@ void myEnsureResized(QWidget *target) { } QPixmap myGrab(TWidget *target, QRect rect) { - myEnsureResized(target); + myEnsureResized(target); if (rect.isNull()) rect = target->rect(); QPixmap result(rect.size() * cRetinaFactor()); diff --git a/Telegram/SourceFiles/gui/twidget.h b/Telegram/SourceFiles/gui/twidget.h index d01504c2b..d1eaeb147 100644 --- a/Telegram/SourceFiles/gui/twidget.h +++ b/Telegram/SourceFiles/gui/twidget.h @@ -24,6 +24,10 @@ namespace App { const QPixmap &sprite(); } +namespace Fonts { + void start(); +} + class Painter : public QPainter { public: explicit Painter(QPaintDevice *device) : QPainter(device) { diff --git a/Telegram/SourceFiles/logs.cpp b/Telegram/SourceFiles/logs.cpp index 46c8cc9df..94a7e5add 100644 --- a/Telegram/SourceFiles/logs.cpp +++ b/Telegram/SourceFiles/logs.cpp @@ -552,6 +552,7 @@ namespace SignalHandlers { FILE *CrashDumpFile = 0; int CrashDumpFileNo = 0; char LaunchedDateTimeStr[32] = { 0 }; + char LaunchedBinaryName[256] = { 0 }; void _writeChar(char ch) { fwrite(&ch, 1, 1, CrashDumpFile); @@ -628,6 +629,8 @@ namespace SignalHandlers { if (!LoggingCrashHeaderWritten) { LoggingCrashHeaderWritten = true; + dump() << "Binary: " << LaunchedBinaryName << "\n"; + dump() << "ApiId: " << ApiId << "\n"; if (cBetaVersion()) { dump() << "Version: " << cBetaVersion() << " beta\n"; } else { @@ -685,6 +688,10 @@ namespace SignalHandlers { } Status restart() { + if (CrashDumpFile) { + return Started; + } + CrashDumpFile = fopen(CrashDumpPath.constData(), "wb"); if (CrashDumpFile) { CrashDumpFileNo = fileno(CrashDumpFile); @@ -693,6 +700,10 @@ namespace SignalHandlers { t_assert(launchedDateTime.size() < sizeof(LaunchedDateTimeStr)); memcpy(LaunchedDateTimeStr, launchedDateTime.constData(), launchedDateTime.size()); + QByteArray launchedBinaryName = cExeName().toUtf8(); + t_assert(launchedBinaryName.size() < sizeof(LaunchedBinaryName)); + memcpy(LaunchedBinaryName, launchedBinaryName.constData(), launchedBinaryName.size()); + signal(SIGABRT, SignalHandlers::Handler); signal(SIGSEGV, SignalHandlers::Handler); signal(SIGILL, SignalHandlers::Handler); diff --git a/Telegram/SourceFiles/pspecific_wnd.cpp b/Telegram/SourceFiles/pspecific_wnd.cpp index 61c6043c7..3407fc421 100644 --- a/Telegram/SourceFiles/pspecific_wnd.cpp +++ b/Telegram/SourceFiles/pspecific_wnd.cpp @@ -2221,7 +2221,7 @@ namespace { } void RegisterCustomScheme() { - #ifndef TDESKTOP_DISABLE_REGISTER_CUSTOM_SCHEME +#ifndef TDESKTOP_DISABLE_REGISTER_CUSTOM_SCHEME DEBUG_LOG(("App Info: Checking custom scheme 'tg'..")); HKEY rkey; @@ -2238,7 +2238,7 @@ void RegisterCustomScheme() { if (!_psOpenRegKey(L"Software\\Classes\\tg\\shell\\open", &rkey)) return; if (!_psOpenRegKey(L"Software\\Classes\\tg\\shell\\open\\command", &rkey)) return; if (!_psSetKeyValue(rkey, 0, '"' + exe + qsl("\" -workdir \"") + cWorkingDir() + qsl("\" -- \"%1\""))) return; - #endif +#endif } void psNewVersion() { @@ -2840,7 +2840,7 @@ void psWriteDump() { } char ImageHlpSymbol64[sizeof(IMAGEHLP_SYMBOL64) + StackEntryMaxNameLength]; -QString _showCrashDump(const QByteArray &crashdump) { +QString _showCrashDump(const QByteArray &crashdump, QString dumpfile) { HANDLE hProcess = GetCurrentProcess(); QString initial = QString::fromUtf8(crashdump), result; @@ -2862,6 +2862,7 @@ QString _showCrashDump(const QByteArray &crashdump) { version /= 1000; } } + ++i; break; } } @@ -2888,8 +2889,13 @@ QString _showCrashDump(const QByteArray &crashdump) { } if (!tolaunch.isEmpty()) { if (QFile(tolaunch).exists()) { - // run it - return QString(); + QString targs = qsl("-crash \"%1\"").arg(dumpfile.replace('"', qsl("\"\""))); + HINSTANCE r = ShellExecute(0, 0, QDir::toNativeSeparators(tolaunch).toStdWString().c_str(), targs.toStdWString().c_str(), 0, SW_SHOWNORMAL); + if (long(r) < 32) { + result.append(qsl("ERROR: executable '%1' with args '%2' for this crashdump could not be launched! Result: %3").arg(tolaunch).arg(targs).arg(long(r))); + } else { + return QString(); + } } else { result.append(qsl("ERROR: executable '%1' for this crashdump was not found!").arg(tolaunch)); } @@ -3088,7 +3094,7 @@ int psShowCrash(const QString &crashdump) { if (!LoadDbgHelp(true)) { text += qsl("ERROR: could not init dbghelp.dll!"); } else { - text += _showCrashDump(dump.readAll()); + text += _showCrashDump(dump.readAll(), crashdump); symCleanup(GetCurrentProcess()); } } else { @@ -3103,14 +3109,7 @@ int psShowCrash(const QString &crashdump) { char *a_argv[1] = { args[0].data() }; QApplication app(a_argc, a_argv); - QTextEdit wnd; - wnd.setReadOnly(true); - wnd.setPlainText(text); - - QRect scr(QApplication::primaryScreen()->availableGeometry()); - wnd.setGeometry(scr.x() + (scr.width() / 6), scr.y() + (scr.height() / 6), scr.width() / 2, scr.height() / 2); - wnd.show(); - + ShowCrashReportWindow wnd(text); return app.exec(); } diff --git a/Telegram/SourceFiles/settings.cpp b/Telegram/SourceFiles/settings.cpp index f539a3a03..7d77c05ee 100644 --- a/Telegram/SourceFiles/settings.cpp +++ b/Telegram/SourceFiles/settings.cpp @@ -200,6 +200,10 @@ void settingsParseArgs(int argc, char *argv[]) { gExeDir = psCurrentExeDirectory(argc, argv); gExeName = psCurrentExeName(argc, argv); + if (argc == 2 && fromUtf8Safe(argv[1]).endsWith(qstr(".telegramcrash")) && QFile(fromUtf8Safe(argv[1])).exists()) { + gLaunchMode = LaunchModeShowCrash; + gStartUrl = fromUtf8Safe(argv[1]); + } for (int32 i = 0; i < argc; ++i) { if (string("-testmode") == argv[i]) { gTestMode = true; diff --git a/Telegram/SourceFiles/settingswidget.cpp b/Telegram/SourceFiles/settingswidget.cpp index 7294a6c4a..ecb5d2468 100644 --- a/Telegram/SourceFiles/settingswidget.cpp +++ b/Telegram/SourceFiles/settingswidget.cpp @@ -329,7 +329,7 @@ SettingsInner::SettingsInner(SettingsWidget *parent) : TWidget(parent) updateOnlineDisplay(); - #ifndef TDESKTOP_DISABLE_AUTOUPDATE +#ifndef TDESKTOP_DISABLE_AUTOUPDATE switch (Sandboxer::updatingState()) { case Application::UpdatingDownload: setUpdatingState(UpdatingDownload, true); @@ -338,9 +338,7 @@ SettingsInner::SettingsInner(SettingsWidget *parent) : TWidget(parent) case Application::UpdatingReady: setUpdatingState(UpdatingReady, true); break; default: setUpdatingState(UpdatingNone, true); break; } - #else - _updatingState = UpdatingNone; - #endif +#endif updateConnectionType(); @@ -1284,7 +1282,7 @@ void SettingsInner::onCheckNow() { #endif void SettingsInner::onRestartNow() { - #ifndef TDESKTOP_DISABLE_AUTOUPDATE +#ifndef TDESKTOP_DISABLE_AUTOUPDATE checkReadyUpdate(); if (_updatingState == UpdatingReady) { cSetRestartingUpdate(true); @@ -1292,10 +1290,10 @@ void SettingsInner::onRestartNow() { cSetRestarting(true); cSetRestartingToSettings(true); } - #else +#else cSetRestarting(true); cSetRestartingToSettings(true); - #endif +#endif App::quit(); } diff --git a/Telegram/SourceFiles/settingswidget.h b/Telegram/SourceFiles/settingswidget.h index 821ce2a67..c8a9c841f 100644 --- a/Telegram/SourceFiles/settingswidget.h +++ b/Telegram/SourceFiles/settingswidget.h @@ -233,6 +233,7 @@ private: QString _curVersionText, _newVersionText; int32 _curVersionWidth, _newVersionWidth; +#ifndef TDESKTOP_DISABLE_AUTOUPDATE enum UpdatingState { UpdatingNone, UpdatingCheck, @@ -243,6 +244,7 @@ private: }; UpdatingState _updatingState; QString _newVersionDownload; +#endif // chat options FlatCheckbox _replaceEmojis; @@ -296,12 +298,10 @@ private: void offPasswordDone(const MTPBool &result); bool offPasswordFail(const RPCError &error); - #ifndef TDESKTOP_DISABLE_AUTOUPDATE +#ifndef TDESKTOP_DISABLE_AUTOUPDATE void setUpdatingState(UpdatingState state, bool force = false); void setDownloadProgress(qint64 ready, qint64 total); - #endif - - +#endif }; class SettingsWidget : public TWidget { @@ -338,7 +338,7 @@ public: public slots: void onParentResize(const QSize &newSize); - + private: void showAll(); diff --git a/Telegram/SourceFiles/stdafx.h b/Telegram/SourceFiles/stdafx.h index 8f285ba20..58a1c065b 100644 --- a/Telegram/SourceFiles/stdafx.h +++ b/Telegram/SourceFiles/stdafx.h @@ -42,6 +42,7 @@ Copyright (c) 2014-2015 John Preston, https://desktop.telegram.org #include #include #include +#include #ifdef Q_OS_WIN // use Lzma SDK for win #include diff --git a/Telegram/SourceFiles/sysbuttons.cpp b/Telegram/SourceFiles/sysbuttons.cpp index 163ba004e..8b618dfd7 100644 --- a/Telegram/SourceFiles/sysbuttons.cpp +++ b/Telegram/SourceFiles/sysbuttons.cpp @@ -148,12 +148,13 @@ UpdateBtn::UpdateBtn(QWidget *parent, Window *window, const QString &text) : Sys } void UpdateBtn::onClick() { - #ifndef TDESKTOP_DISABLE_AUTOUPDATE +#ifndef TDESKTOP_DISABLE_AUTOUPDATE checkReadyUpdate(); - #endif if (Sandboxer::updatingState() == Application::UpdatingReady) { cSetRestartingUpdate(true); - } else { + } else +#endif + { cSetRestarting(true); cSetRestartingToSettings(false); } diff --git a/Telegram/SourceFiles/title.cpp b/Telegram/SourceFiles/title.cpp index 83cb69090..86c55de51 100644 --- a/Telegram/SourceFiles/title.cpp +++ b/Telegram/SourceFiles/title.cpp @@ -73,7 +73,12 @@ TitleWidget::TitleWidget(Window *window) : TWidget(window) _update.hide(); _cancel.hide(); _back.hide(); - if (Sandboxer::updatingState() == Application::UpdatingReady || cHasPasscode()) { + if ( +#ifndef TDESKTOP_DISABLE_AUTOUPDATE + Sandboxer::updatingState() == Application::UpdatingReady || +#endif + cHasPasscode() + ) { showUpdateBtn(); } stateChanged(); @@ -322,7 +327,11 @@ void TitleWidget::showUpdateBtn() { } else { _lock.hide(); } +#ifndef TDESKTOP_DISABLE_AUTOUPDATE bool updateReady = (Sandboxer::updatingState() == Application::UpdatingReady); +#else + bool updateReady = false; +#endif if (updateReady || cEvalScale(cConfigScale()) != cEvalScale(cRealScale())) { _update.setText(lang(updateReady ? lng_menu_update : lng_menu_restart)); _update.show(); diff --git a/Telegram/SourceFiles/window.cpp b/Telegram/SourceFiles/window.cpp index 7c6ad727e..e54c8e274 100644 --- a/Telegram/SourceFiles/window.cpp +++ b/Telegram/SourceFiles/window.cpp @@ -36,9 +36,13 @@ Copyright (c) 2014-2015 John Preston, https://desktop.telegram.org #include "boxes/contactsbox.h" #include "boxes/addcontactbox.h" +#include "autoupdater.h" + #include "mediaview.h" #include "localstorage.h" +#include "_other/zip.h" + ConnectingWidget::ConnectingWidget(QWidget *parent, const QString &text, const QString &reconnect) : QWidget(parent), _shadow(st::boxShadow), _reconnect(this, QString()) { set(text, reconnect); connect(&_reconnect, SIGNAL(clicked()), this, SLOT(onReconnect())); @@ -451,7 +455,6 @@ void Window::firstShow() { trayIconMenu->deleteOnHide(false); #else trayIconMenu = new QMenu(this); - trayIconMenu->setFont(QFont("Tahoma")); #endif QString notificationItem = lang(cDesktopNotify() ? lng_disable_notifications_from_tray : lng_enable_notifications_from_tray); @@ -1826,61 +1829,1046 @@ Window::~Window() { delete settings; } -NotStartedWindow::NotStartedWindow() : TWidget(0) -, _label(this) -, _log(this) { - _label.setText(qsl("Could not start Telegram Desktop! Log:")); - _label.show(); +PreLaunchWindow *PreLaunchWindowInstance = 0; + +PreLaunchWindow::PreLaunchWindow(QString title) : TWidget(0) { + Fonts::start(); + + QIcon icon(QPixmap::fromImage(QImage(cPlatform() == dbipMac ? qsl(":/gui/art/iconbig256.png") : qsl(":/gui/art/icon256.png")), Qt::ColorOnly)); + if (cPlatform() == dbipLinux32 || cPlatform() == dbipLinux64) { + icon = QIcon::fromTheme("telegram", icon); + } + setWindowIcon(icon); + setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint); + + setWindowTitle(title.isEmpty() ? qsl("Telegram") : title); + + QPalette p(palette()); + p.setColor(QPalette::Background, QColor(255, 255, 255)); + setPalette(p); + + QLabel tmp(this); + tmp.setText(qsl("Tmp")); + _size = tmp.sizeHint().height(); + + setStyleSheet(qsl("QPushButton { padding: %1px %2px; background-color: #ffffff; border-radius: %3px; }\nQPushButton#confirm:hover, QPushButton#cancel:hover { background-color: #edf7ff; color: #2f9fea; }\nQPushButton#confirm { color: #2f9fea; }\nQPushButton#cancel { color: #aeaeae; }\nQLineEdit { border: 1px solid #e0e0e0; padding: 5px; }\nQLineEdit:focus { border: 2px solid #62c0f7; padding: 4px; }").arg(qFloor(_size / 2)).arg(qFloor(_size)).arg(qFloor(_size / 5))); + if (!PreLaunchWindowInstance) { + PreLaunchWindowInstance = this; + } +} + +void PreLaunchWindow::activate() { + setWindowState(windowState() & ~Qt::WindowMinimized); + setVisible(true); + psActivateProcess(); + activateWindow(); +} + +PreLaunchWindow *PreLaunchWindow::instance() { + return PreLaunchWindowInstance; +} + +PreLaunchWindow::~PreLaunchWindow() { + if (PreLaunchWindowInstance == this) { + PreLaunchWindowInstance = 0; + } +} + +PreLaunchLabel::PreLaunchLabel(QWidget *parent) : QLabel(parent) { + QFont labelFont(font()); + labelFont.setFamily(qsl("Open Sans Semibold")); + labelFont.setPixelSize(static_cast(parent)->basicSize()); + setFont(labelFont); + + QPalette p(palette()); + p.setColor(QPalette::Foreground, QColor(0, 0, 0)); + setPalette(p); + show(); +}; + +void PreLaunchLabel::setText(const QString &text) { + QLabel::setText(text); + updateGeometry(); + resize(sizeHint()); +} + +PreLaunchInput::PreLaunchInput(QWidget *parent, bool password) : QLineEdit(parent) { + QFont logFont(font()); + logFont.setFamily(qsl("Open Sans")); + logFont.setPixelSize(static_cast(parent)->basicSize()); + setFont(logFont); + + QPalette p(palette()); + p.setColor(QPalette::Foreground, QColor(0, 0, 0)); + setPalette(p); + + QLineEdit::setTextMargins(0, 0, 0, 0); + setContentsMargins(0, 0, 0, 0); + if (password) { + setEchoMode(QLineEdit::Password); + } + show(); +}; + +PreLaunchLog::PreLaunchLog(QWidget *parent) : QTextEdit(parent) { + QFont logFont(font()); + logFont.setFamily(qsl("Open Sans")); + logFont.setPixelSize(static_cast(parent)->basicSize()); + setFont(logFont); + + QPalette p(palette()); + p.setColor(QPalette::Foreground, QColor(96, 96, 96)); + setPalette(p); + + setReadOnly(true); + setFrameStyle(QFrame::NoFrame | QFrame::Plain); + viewport()->setAutoFillBackground(false); + setContentsMargins(0, 0, 0, 0); + document()->setDocumentMargin(0); + show(); +}; + +PreLaunchButton::PreLaunchButton(QWidget *parent, bool confirm) : QPushButton(parent) { + setFlat(true); + + setObjectName(confirm ? "confirm" : "cancel"); + + QFont closeFont(font()); + closeFont.setFamily(qsl("Open Sans Semibold")); + closeFont.setPixelSize(static_cast(parent)->basicSize()); + setFont(closeFont); + + setCursor(Qt::PointingHandCursor); + show(); +}; + +void PreLaunchButton::setText(const QString &text) { + QPushButton::setText(text); + updateGeometry(); + resize(sizeHint()); +} + +NotStartedWindow::NotStartedWindow() +: _label(this) +, _log(this) +, _close(this) { + _label.setText(qsl("Could not start Telegram Desktop!\nYou can see complete log below:")); - _log.setReadOnly(true); _log.setPlainText(Logs::full()); - _log.show(); + + connect(&_close, SIGNAL(clicked()), this, SLOT(close())); + _close.setText(qsl("CLOSE")); QRect scr(QApplication::primaryScreen()->availableGeometry()); - setGeometry(scr.x() + (scr.width() / 6), scr.y() + (scr.height() / 6), scr.width() / 2, scr.height() / 2); + move(scr.x() + (scr.width() / 6), scr.y() + (scr.height() / 6)); + updateControls(); show(); } +void NotStartedWindow::updateControls() { + _label.show(); + _log.show(); + _close.show(); + + QRect scr(QApplication::primaryScreen()->availableGeometry()); + QSize s(scr.width() / 2, scr.height() / 2); + if (s == size()) { + resizeEvent(0); + } else { + resize(s); + } +} + void NotStartedWindow::closeEvent(QCloseEvent *e) { deleteLater(); } void NotStartedWindow::resizeEvent(QResizeEvent *e) { - int padding = _label.sizeHint().height() / 2; + int padding = _size; _label.setGeometry(padding, padding, width() - 2 * padding, _label.sizeHint().height()); - _log.setGeometry(padding, padding * 2 + _label.sizeHint().height(), width() - 2 * padding, height() - 3 * padding - _label.sizeHint().height()); + _log.setGeometry(padding, padding * 2 + _label.sizeHint().height(), width() - 2 * padding, height() - 4 * padding - _label.height() - _close.height()); + _close.setGeometry(width() - padding - _close.width(), height() - padding - _close.height(), _close.width(), _close.height()); } -LastCrashedWindow::LastCrashedWindow() : TWidget(0) +LastCrashedWindow::LastCrashedWindow() +: _port(80) , _label(this) -, _log(this) -, _send(this) { - _label.setText(qsl("Could not start Telegram Desktop! Log:")); +, _pleaseSendReport(this) +, _minidump(this) +, _report(this) +, _send(this) +, _sendSkip(this, false) +, _networkSettings(this) +, _continue(this) +, _showReport(this) +, _saveReport(this) +, _getApp(this) +, _reportText(QString::fromUtf8(Global::LastCrashDump())) +, _reportShown(false) +, _reportSaved(false) +, _sendingState(Global::LastCrashDump().isEmpty() ? SendingNoReport : SendingUpdateCheck) +, _updating(this) +, _sendingProgress(0) +, _sendingTotal(0) +, _checkReply(0) +, _sendReply(0) +#ifndef TDESKTOP_DISABLE_AUTOUPDATE +, _updatingCheck(this) +, _updatingSkip(this, false) +#endif +{ + +#ifdef Q_OS_WIN + if (_sendingState != SendingNoReport) { + QString maxDump, maxDumpFull; + QDateTime maxDumpModified; + qint64 maxDumpSize = 0; + QFileInfoList list = QDir(cWorkingDir() + qsl("tdumps")).entryInfoList(); + for (int32 i = 0, l = list.size(); i < l; ++i) { + if (maxDump.isEmpty() || maxDumpModified < list.at(i).lastModified()) { + maxDump = list.at(i).fileName(); + maxDumpFull = list.at(i).absoluteFilePath(); + maxDumpModified = list.at(i).lastModified(); + maxDumpSize = list.at(i).size(); + } + } + if (!maxDump.isEmpty()) { + if (qAbs(QFileInfo(cWorkingDir() + qsl("tdata/working")).lastModified().secsTo(maxDumpModified)) < 10) { + _minidumpName = maxDump; + _minidumpFull = maxDumpFull; + } + } + + _minidump.setText(qsl("+ %1 (%2 KB)").arg(_minidumpName).arg(maxDumpSize / 1024)); + } +#endif + + _networkSettings.setText(qsl("NETWORK SETTINGS")); + connect(&_networkSettings, SIGNAL(clicked()), this, SLOT(onNetworkSettings())); + + if (_sendingState == SendingNoReport) { + _label.setText(qsl("Last time Telegram Desktop was not closed properly.")); + } else { + _label.setText(qsl("Last time Telegram Desktop crashed :(")); + } + +#ifndef TDESKTOP_DISABLE_AUTOUPDATE + _updatingCheck.setText(qsl("TRY AGAIN")); + connect(&_updatingCheck, SIGNAL(clicked()), this, SLOT(onUpdateRetry())); + _updatingSkip.setText(qsl("SKIP")); + connect(&_updatingSkip, SIGNAL(clicked()), this, SLOT(onUpdateSkip())); + + Sandboxer::connect(SIGNAL(updateChecking()), this, SLOT(onUpdateChecking())); + Sandboxer::connect(SIGNAL(updateLatest()), this, SLOT(onUpdateLatest())); + Sandboxer::connect(SIGNAL(updateProgress(qint64,qint64)), this, SLOT(onUpdateDownloading(qint64,qint64))); + Sandboxer::connect(SIGNAL(updateFailed()), this, SLOT(onUpdateFailed())); + Sandboxer::connect(SIGNAL(updateReady()), this, SLOT(onUpdateReady())); + + switch (Sandboxer::updatingState()) { + case Application::UpdatingDownload: + setUpdatingState(UpdatingDownload, true); + setDownloadProgress(Sandboxer::updatingReady(), Sandboxer::updatingSize()); + break; + case Application::UpdatingReady: setUpdatingState(UpdatingReady, true); break; + default: setUpdatingState(UpdatingCheck, true); break; + } + + cSetLastUpdateCheck(0); + Sandboxer::startUpdateCheck(); +#else + _updating.setText(qsl("Please check if there is a new version available.")); + if (_sendingState != SendingNoReport) { + _sendingState = SendingNone; + } +#endif + + _pleaseSendReport.setText(qsl("Please send us a crash report.")); + + _report.setPlainText(_reportText); + + _showReport.setText(qsl("VIEW REPORT")); + connect(&_showReport, SIGNAL(clicked()), this, SLOT(onViewReport())); + _saveReport.setText(qsl("SAVE TO FILE")); + connect(&_saveReport, SIGNAL(clicked()), this, SLOT(onSaveReport())); + _getApp.setText(qsl("GET THE LATEST OFFICIAL VERSION OF TELEGRAM DESKTOP")); + connect(&_getApp, SIGNAL(clicked()), this, SLOT(onGetApp())); + + _send.setText(qsl("SEND CRASH REPORT")); + connect(&_send, SIGNAL(clicked()), this, SLOT(onSendReport())); + + _sendSkip.setText(qsl("SKIP")); + connect(&_sendSkip, SIGNAL(clicked()), this, SLOT(onContinue())); + _continue.setText(qsl("CONTINUE")); + connect(&_continue, SIGNAL(clicked()), this, SLOT(onContinue())); + + QRect scr(QApplication::primaryScreen()->availableGeometry()); + move(scr.x() + (scr.width() / 6), scr.y() + (scr.height() / 6)); + updateControls(); + show(); +} + +void LastCrashedWindow::onViewReport() { + _reportShown = !_reportShown; + updateControls(); +} + +void LastCrashedWindow::onSaveReport() { + QString to = QFileDialog::getSaveFileName(0, qsl("Telegram Crash Report"), QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation) + qsl("/report"), qsl("Telegram crash report (*.telegramcrash)")); + if (!to.isEmpty()) { + QFile file(to); + if (file.open(QIODevice::WriteOnly)) { + file.write(Global::LastCrashDump()); + _reportSaved = true; + updateControls(); + } + } +} + +void LastCrashedWindow::onGetApp() { + QDesktopServices::openUrl(qsl("https://desktop.telegram.org")); +} + +QString LastCrashedWindow::getReportField(const QLatin1String &name, const QLatin1String &prefix) { + QStringList lines = _reportText.split('\n'); + for (int32 i = 0, l = lines.size(); i < l; ++i) { + if (lines.at(i).trimmed().startsWith(prefix)) { + QString data = lines.at(i).trimmed().mid(prefix.size()).trimmed(); + + if (name == qstr("version")) { + if (data.endsWith(qstr(" beta"))) { + data = QString::number(-data.replace(QRegularExpression(qsl("[^\\d]")), "").mid(0, data.size() - 5).toLongLong()); + } else { + data = QString::number(data.replace(QRegularExpression(qsl("[^\\d]")), "").toLongLong()); + } + } + + return data; + } + } + return QString(); +} + +void LastCrashedWindow::addReportFieldPart(const QLatin1String &name, const QLatin1String &prefix, QHttpMultiPart *multipart) { + QString data = getReportField(name, prefix); + if (!data.isEmpty()) { + QHttpPart reportPart; + reportPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(qsl("form-data; name=\"%1\"").arg(name))); + reportPart.setBody(data.toUtf8()); + multipart->append(reportPart); + } +} + +void LastCrashedWindow::onSendReport() { + if (_checkReply) { + _checkReply->deleteLater(); + _checkReply = 0; + } + if (_sendReply) { + _sendReply->deleteLater(); + _sendReply = 0; + } + App::setProxySettings(_sendManager); + + QString apiid = getReportField(qstr("apiid"), qstr("ApiId:")), version = getReportField(qstr("version"), qstr("Version:")); + _checkReply = _sendManager.get(QNetworkRequest(qsl("https://tdesktop.com/crash.php?act=query_report&apiid=%1&version=%2").arg(apiid).arg(version))); + + connect(_checkReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onSendingError(QNetworkReply::NetworkError))); + connect(_checkReply, SIGNAL(finished()), this, SLOT(onCheckingFinished())); + + _pleaseSendReport.setText(qsl("Sending crash report..")); + _sendingState = SendingProgress; + _reportShown = false; + updateControls(); +} + +namespace { + struct zByteArray { + zByteArray() : pos(0), err(0) { + } + uLong pos; + int err; + QByteArray data; + }; + + voidpf zByteArrayOpenFile(voidpf opaque, const char* filename, int mode) { + zByteArray *ba = (zByteArray*)opaque; + if (mode & ZLIB_FILEFUNC_MODE_WRITE) { + if (mode & ZLIB_FILEFUNC_MODE_CREATE) { + ba->data.clear(); + } + ba->pos = ba->data.size(); + ba->data.reserve(2 * 1024 * 1024); + } else if (mode & ZLIB_FILEFUNC_MODE_READ) { + ba->pos = 0; + } + ba->err = 0; + return opaque; + } + + uLong zByteArrayReadFile(voidpf opaque, voidpf stream, void* buf, uLong size) { + zByteArray *ba = (zByteArray*)opaque; + uLong toRead = 0; + if (!ba->err) { + if (ba->data.size() > ba->pos) { + toRead = qMin(size, uLong(ba->data.size() - ba->pos)); + memcpy(buf, ba->data.constData() + ba->pos, toRead); + ba->pos += toRead; + } + if (toRead < size) { + ba->err = -1; + } + } + return toRead; + } + + uLong zByteArrayWriteFile(voidpf opaque, voidpf stream, const void* buf, uLong size) { + zByteArray *ba = (zByteArray*)opaque; + if (ba->data.size() < ba->pos + size) { + ba->data.resize(ba->pos + size); + } + memcpy(ba->data.data() + ba->pos, buf, size); + ba->pos += size; + return size; + } + + int zByteArrayCloseFile(voidpf opaque, voidpf stream) { + zByteArray *ba = (zByteArray*)opaque; + int result = ba->err; + ba->pos = 0; + ba->err = 0; + return result; + } + + int zByteArrayErrorFile(voidpf opaque, voidpf stream) { + zByteArray *ba = (zByteArray*)opaque; + return ba->err; + } + + long zByteArrayTellFile(voidpf opaque, voidpf stream) { + zByteArray *ba = (zByteArray*)opaque; + return ba->pos; + } + + long zByteArraySeekFile(voidpf opaque, voidpf stream, uLong offset, int origin) { + zByteArray *ba = (zByteArray*)opaque; + if (!ba->err) { + switch (origin) { + case ZLIB_FILEFUNC_SEEK_SET: ba->pos = offset; break; + case ZLIB_FILEFUNC_SEEK_CUR: ba->pos += offset; break; + case ZLIB_FILEFUNC_SEEK_END: ba->pos = ba->data.size() + offset; break; + } + if (ba->pos > ba->data.size()) { + ba->err = -1; + } + } + return ba->err; + } + +} + +void LastCrashedWindow::onCheckingFinished() { + if (!_checkReply || _sendReply) return; + + QByteArray result = _checkReply->readAll().trimmed(); + _checkReply->deleteLater(); + _checkReply = 0; + + LOG(("Crash report check for sending done, result: %1").arg(QString::fromUtf8(result))); + + if (result == "Many") { + _pleaseSendReport.setText(qsl("Too many crash reports at this moment :(")); + _sendingState = SendingTooMany; + updateControls(); + return; + } else if (result == "Unofficial") { + _pleaseSendReport.setText(qsl("You use some custom version of Telegram Desktop.")); + _sendingState = SendingUnofficial; + updateControls(); + return; + } else if (result != "Report") { + _pleaseSendReport.setText(qsl("This report is about some old version of Telegram Desktop.")); + _sendingState = SendingTooOld; + updateControls(); + return; + } + + QHttpMultiPart *multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType); + + addReportFieldPart(qstr("platform"), qstr("Platform:"), multipart); + addReportFieldPart(qstr("version"), qstr("Version:"), multipart); + + QHttpPart reportPart; + reportPart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/octet-stream")); + reportPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"report\"; filename=\"report.telegramcrash\"")); + reportPart.setBody(Global::LastCrashDump()); + multipart->append(reportPart); + + QFileInfo dmpFile(_minidumpFull); + if (dmpFile.exists() && dmpFile.size() > 0 && dmpFile.size() < 20 * 1024 * 1024 && + QRegularExpression(qsl("^Telegram\\-[\\d\\.\\-]{1,64}\\.dmp$")).match(dmpFile.fileName()).hasMatch()) { + QFile file(_minidumpFull); + if (file.open(QIODevice::ReadOnly)) { + QByteArray minidump = file.readAll(); + file.close(); + + QString zipName = dmpFile.fileName().replace(qstr(".dmp"), qstr(".zip")); + zByteArray minidumpZip; + + bool failed = false; + zlib_filefunc_def zfuncs; + zfuncs.opaque = &minidumpZip; + zfuncs.zopen_file = zByteArrayOpenFile; + zfuncs.zerror_file = zByteArrayErrorFile; + zfuncs.zread_file = zByteArrayReadFile; + zfuncs.zwrite_file = zByteArrayWriteFile; + zfuncs.zclose_file = zByteArrayCloseFile; + zfuncs.zseek_file = zByteArraySeekFile; + zfuncs.ztell_file = zByteArrayTellFile; + + if (zipFile zf = zipOpen2(0, APPEND_STATUS_CREATE, 0, &zfuncs)) { + zip_fileinfo zfi = { 0 }; + std::wstring fileName = dmpFile.fileName().toStdWString(); + if (zipOpenNewFileInZip(zf, std::string(fileName.begin(), fileName.end()).c_str(), &zfi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION) != S_OK) { + failed = true; + } else if (zipWriteInFileInZip(zf, minidump.constData(), minidump.size()) != 0) { + failed = true; + } else if (zipCloseFileInZip(zf) != 0) { + failed = true; + } + if (zipClose(zf, NULL) != 0) { + failed = true; + } + if (failed) { + minidumpZip.err = -1; + } + } + + if (!minidumpZip.err) { + QHttpPart dumpPart; + dumpPart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/octet-stream")); + dumpPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(qsl("form-data; name=\"dump\"; filename=\"%1\"").arg(zipName))); + dumpPart.setBody(minidumpZip.data); + multipart->append(dumpPart); + + _minidump.setText(qsl("+ %1 (%2 KB)").arg(zipName).arg(minidumpZip.data.size() / 1024)); + } + } + } + + _sendReply = _sendManager.post(QNetworkRequest(qsl("https://tdesktop.com/crash.php?act=report")), multipart); + multipart->setParent(_sendReply); + + connect(_sendReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onSendingError(QNetworkReply::NetworkError))); + connect(_sendReply, SIGNAL(finished()), this, SLOT(onSendingFinished())); + connect(_sendReply, SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(onSendingProgress(qint64,qint64))); + + updateControls(); +} + +void LastCrashedWindow::updateControls() { + int padding = _size, h = padding + _networkSettings.height() + padding; + _label.show(); +#ifndef TDESKTOP_DISABLE_AUTOUPDATE + h += _networkSettings.height() + padding; + if (_updatingState == UpdatingFail && (_sendingState == SendingNoReport || _sendingState == SendingUpdateCheck)) { + _networkSettings.show(); + _updatingCheck.show(); + _updatingSkip.show(); + _send.hide(); + _sendSkip.hide(); + _continue.hide(); + _pleaseSendReport.hide(); + _getApp.hide(); + _showReport.hide(); + _report.hide(); + _minidump.hide(); + _saveReport.hide(); + h += padding + _updatingCheck.height() + padding; + } else { + if (_updatingState == UpdatingCheck || _sendingState == SendingFail || _sendingState == SendingProgress) { + _networkSettings.show(); + } else { + _networkSettings.hide(); + } + if (_updatingState == UpdatingNone || _updatingState == UpdatingLatest || _updatingState == UpdatingFail) { + h += padding + _updatingCheck.height() + padding; + if (_sendingState == SendingNoReport) { + _pleaseSendReport.hide(); + _getApp.hide(); + _showReport.hide(); + _report.hide(); + _minidump.hide(); + _saveReport.hide(); + _send.hide(); + _sendSkip.hide(); + _continue.show(); + } else { + h += _showReport.height() + padding; + _pleaseSendReport.show(); + if (_sendingState == SendingTooOld || _sendingState == SendingUnofficial) { + QString verStr = getReportField(qstr("version"), qstr("Version:")); + qint64 ver = verStr.isEmpty() ? 0 : verStr.toLongLong(); + if (!ver || (ver == AppVersion) || (ver < 0 && (-ver / 1000) == AppVersion)) { + h += _getApp.height() + padding; + _getApp.show(); + } else { + _getApp.hide(); + } + _showReport.hide(); + _report.hide(); + _minidump.hide(); + _saveReport.hide(); + _send.hide(); + _sendSkip.hide(); + _continue.show(); + } else { + _getApp.hide(); + if (_reportShown) { + h += (_pleaseSendReport.height() * 12.5) + padding + (_minidumpName.isEmpty() ? 0 : (_minidump.height() + padding)); + _report.show(); + if (_minidumpName.isEmpty()) { + _minidump.hide(); + } else { + _minidump.show(); + } + if (_reportSaved || _sendingState == SendingFail || _sendingState == SendingProgress || _sendingState == SendingUploading) { + _saveReport.hide(); + } else { + _saveReport.show(); + } + _showReport.hide(); + } else { + _report.hide(); + _minidump.hide(); + _saveReport.hide(); + if (_sendingState == SendingFail || _sendingState == SendingProgress || _sendingState == SendingUploading) { + _showReport.hide(); + } else { + _showReport.show(); + } + } + if (_sendingState == SendingTooMany || _sendingState == SendingDone) { + _send.hide(); + _sendSkip.hide(); + _continue.show(); + } else { + if (_sendingState == SendingProgress || _sendingState == SendingUploading) { + _send.hide(); + } else { + _send.show(); + } + _sendSkip.show(); + _continue.hide(); + } + } + } + } else { + _getApp.hide(); + _pleaseSendReport.hide(); + _showReport.hide(); + _report.hide(); + _minidump.hide(); + _saveReport.hide(); + _send.hide(); + _sendSkip.hide(); + _continue.hide(); + } + _updatingCheck.hide(); + if (_updatingState == UpdatingCheck || _updatingState == UpdatingDownload) { + h += padding + _updatingSkip.height() + padding; + _updatingSkip.show(); + } else { + _updatingSkip.hide(); + } + } +#else + h += _networkSettings.height() + padding; + h += padding + _send.height() + padding; + if (_sendingState == SendingNoReport) { + _pleaseSendReport.hide(); + _showReport.hide(); + _report.hide(); + _minidump.hide(); + _saveReport.hide(); + _send.hide(); + _sendSkip.hide(); + _continue.show(); + _networkSettings.hide(); + } else { + h += _showReport.height() + padding; + _pleaseSendReport.show(); + if (_reportShown) { + h += (_pleaseSendReport.height() * 12.5) + padding + (_minidumpName.isEmpty() ? 0 : (_minidump.height() + padding)); + _report.show(); + if (_minidumpName.isEmpty()) { + _minidump.hide(); + } else { + _minidump.show(); + } + _showReport.hide(); + if (_reportSaved || _sendingState == SendingFail || _sendingState == SendingProgress || _sendingState == SendingUploading) { + _saveReport.hide(); + } else { + _saveReport.show(); + } + } else { + _report.hide(); + _minidump.hide(); + _saveReport.hide(); + if (_sendingState == SendingFail || _sendingState == SendingProgress || _sendingState == SendingUploading) { + _showReport.hide(); + } else { + _showReport.show(); + } + } + if (_sendingState == SendingDone) { + _send.hide(); + _sendSkip.hide(); + _continue.show(); + _networkSettings.hide(); + } else { + if (_sendingState == SendingProgress || _sendingState == SendingUploading) { + _send.hide(); + } else { + _send.show(); + } + _sendSkip.show(); + if (_sendingState == SendingFail) { + _networkSettings.show(); + } else { + _networkSettings.hide(); + } + _continue.hide(); + } + } - _log.setReadOnly(true); - _log.setPlainText(Logs::full()); - _log.show(); + _getApp.show(); + h += _networkSettings.height() + padding; +#endif - _send.setText(qsl("Send Crash Report")); - _send.show(); + QRect scr(QApplication::primaryScreen()->availableGeometry()); + QSize s(2 * padding + QFontMetrics(_label.font()).width(qsl("Last time Telegram Desktop was not closed properly.")) + padding + _networkSettings.width(), h); + if (s == size()) { + resizeEvent(0); + } else { + resize(s); + } +} + +void LastCrashedWindow::onNetworkSettings() { + const ConnectionProxy &p(Global::PreLaunchProxy()); + NetworkSettingsWindow *box = new NetworkSettingsWindow(this, p.host, p.port ? p.port : 80, p.user, p.password); + connect(box, SIGNAL(saved(QString, quint32, QString, QString)), this, SLOT(onNetworkSettingsSaved(QString, quint32, QString, QString))); + box->show(); +} + +void LastCrashedWindow::onNetworkSettingsSaved(QString host, quint32 port, QString username, QString password) { + Global::RefPreLaunchProxy().host = host; + Global::RefPreLaunchProxy().port = port ? port : 80; + Global::RefPreLaunchProxy().user = username; + Global::RefPreLaunchProxy().password = password; +#ifndef TDESKTOP_DISABLE_AUTOUPDATE + if ((_updatingState == UpdatingFail && (_sendingState == SendingNoReport || _sendingState == SendingUpdateCheck)) || (_updatingState == UpdatingCheck)) { + Sandboxer::stopUpdate(); + cSetLastUpdateCheck(0); + Sandboxer::startUpdateCheck(); + } else +#endif + if (_sendingState == SendingFail || _sendingState == SendingProgress) { + onSendReport(); + } + activate(); +} + +#ifndef TDESKTOP_DISABLE_AUTOUPDATE +void LastCrashedWindow::setUpdatingState(UpdatingState state, bool force) { + if (_updatingState != state || force) { + _updatingState = state; + switch (state) { + case UpdatingLatest: + _updating.setText(qsl("Latest version is installed.")); + if (_sendingState == SendingNoReport) { + QTimer::singleShot(0, this, SLOT(onContinue())); + } else { + _sendingState = SendingNone; + } + break; + case UpdatingReady: + if (checkReadyUpdate()) { + cSetRestartingUpdate(true); + App::quit(); + return; + } else { + setUpdatingState(UpdatingFail); + return; + } + break; + case UpdatingCheck: + _updating.setText(qsl("Checking for updates..")); + break; + case UpdatingFail: + _updating.setText(qsl("Update check failed :(")); + break; + } + updateControls(); + } +} + +void LastCrashedWindow::setDownloadProgress(qint64 ready, qint64 total) { + qint64 readyTenthMb = (ready * 10 / (1024 * 1024)), totalTenthMb = (total * 10 / (1024 * 1024)); + QString readyStr = QString::number(readyTenthMb / 10) + '.' + QString::number(readyTenthMb % 10); + QString totalStr = QString::number(totalTenthMb / 10) + '.' + QString::number(totalTenthMb % 10); + QString res = qsl("Downloading update {ready} / {total} MB..").replace(qstr("{ready}"), readyStr).replace(qstr("{total}"), totalStr); + if (_newVersionDownload != res) { + _newVersionDownload = res; + _updating.setText(_newVersionDownload); + updateControls(); + } +} + +void LastCrashedWindow::onUpdateRetry() { + cSetLastUpdateCheck(0); + Sandboxer::startUpdateCheck(); +} + +void LastCrashedWindow::onUpdateSkip() { + if (_sendingState == SendingNoReport) { + onContinue(); + } else { + if (_updatingState == UpdatingCheck || _updatingState == UpdatingDownload) { + Sandboxer::stopUpdate(); + setUpdatingState(UpdatingFail); + } + _sendingState = SendingNone; + updateControls(); + } +} + +void LastCrashedWindow::onUpdateChecking() { + setUpdatingState(UpdatingCheck); +} + +void LastCrashedWindow::onUpdateLatest() { + setUpdatingState(UpdatingLatest); +} + +void LastCrashedWindow::onUpdateDownloading(qint64 ready, qint64 total) { + setUpdatingState(UpdatingDownload); + setDownloadProgress(ready, total); +} + +void LastCrashedWindow::onUpdateReady() { + setUpdatingState(UpdatingReady); +} + +void LastCrashedWindow::onUpdateFailed() { + setUpdatingState(UpdatingFail); +} +#endif + +void LastCrashedWindow::onContinue() { + if (SignalHandlers::restart() == SignalHandlers::CantOpen) { + new NotStartedWindow(); + } else { + new AppClass(); + } + close(); +} + +void LastCrashedWindow::onSendingError(QNetworkReply::NetworkError e) { + LOG(("Crash report sending error: %1").arg(e)); + + _pleaseSendReport.setText(qsl("Sending crash report failed :(")); + _sendingState = SendingFail; + if (_checkReply) { + _checkReply->deleteLater(); + _checkReply = 0; + } + if (_sendReply) { + _sendReply->deleteLater(); + _sendReply = 0; + } + updateControls(); +} + +void LastCrashedWindow::onSendingFinished() { + if (_sendReply) { + QByteArray result = _sendReply->readAll(); + LOG(("Crash report sending done, result: %1").arg(QString::fromUtf8(result))); + + _sendReply->deleteLater(); + _sendReply = 0; + _pleaseSendReport.setText(qsl("Thank you for your report!")); + _sendingState = SendingDone; + updateControls(); + + SignalHandlers::restart(); + } +} + +void LastCrashedWindow::onSendingProgress(qint64 uploaded, qint64 total) { + if (_sendingState != SendingProgress && _sendingState != SendingUploading) return; + _sendingState = SendingUploading; + + if (total < 0) { + _pleaseSendReport.setText(qsl("Sending crash report %1 KB..").arg(uploaded / 1024)); + } else { + _pleaseSendReport.setText(qsl("Sending crash report %1 / %2 KB..").arg(uploaded / 1024).arg(total / 1024)); + } + updateControls(); +} + +void LastCrashedWindow::closeEvent(QCloseEvent *e) { + deleteLater(); +} + +void LastCrashedWindow::resizeEvent(QResizeEvent *e) { + int padding = _size; + _label.move(padding, padding + (_networkSettings.height() - _label.height()) / 2); + + _send.move(width() - padding - _send.width(), height() - padding - _send.height()); + if (_sendingState == SendingProgress || _sendingState == SendingUploading) { + _sendSkip.move(width() - padding - _sendSkip.width(), height() - padding - _sendSkip.height()); + } else { + _sendSkip.move(width() - padding - _send.width() - padding - _sendSkip.width(), height() - padding - _sendSkip.height()); + } + + _updating.move(padding, padding * 2 + _networkSettings.height() + (_networkSettings.height() - _updating.height()) / 2); + +#ifndef TDESKTOP_DISABLE_AUTOUPDATE + _pleaseSendReport.move(padding, padding * 2 + _networkSettings.height() + _networkSettings.height() + padding + (_showReport.height() - _pleaseSendReport.height()) / 2); + _showReport.move(padding * 2 + _pleaseSendReport.width(), padding * 2 + _networkSettings.height() + _networkSettings.height() + padding); + _getApp.move((width() - _getApp.width()) / 2, _showReport.y() + _showReport.height() + padding); + + if (_sendingState == SendingFail || _sendingState == SendingProgress) { + _networkSettings.move(padding * 2 + _pleaseSendReport.width(), padding * 2 + _networkSettings.height() + _networkSettings.height() + padding); + } else { + _networkSettings.move(padding * 2 + _updating.width(), padding * 2 + _networkSettings.height()); + } + + if (_updatingState == UpdatingCheck || _updatingState == UpdatingDownload) { + _updatingCheck.move(width() - padding - _updatingCheck.width(), height() - padding - _updatingCheck.height()); + _updatingSkip.move(width() - padding - _updatingSkip.width(), height() - padding - _updatingSkip.height()); + } else { + _updatingCheck.move(width() - padding - _updatingCheck.width(), height() - padding - _updatingCheck.height()); + _updatingSkip.move(width() - padding - _updatingCheck.width() - padding - _updatingSkip.width(), height() - padding - _updatingSkip.height()); + } +#else + _getApp.move((width() - _getApp.width()) / 2, _updating.y() + _updating.height() + padding); + + _pleaseSendReport.move(padding, padding * 2 + _networkSettings.height() + _networkSettings.height() + padding + _getApp.height() + padding + (_showReport.height() - _pleaseSendReport.height()) / 2); + _showReport.move(padding * 2 + _pleaseSendReport.width(), padding * 2 + _networkSettings.height() + _networkSettings.height() + padding + _getApp.height() + padding); + + _networkSettings.move(padding * 2 + _pleaseSendReport.width(), padding * 2 + _networkSettings.height() + _networkSettings.height() + padding + _getApp.height() + padding); +#endif + + _report.setGeometry(padding, _showReport.y() + _showReport.height() + padding, width() - 2 * padding, _pleaseSendReport.height() * 12.5); + _minidump.move(padding, _report.y() + _report.height() + padding); + _saveReport.move(_showReport.x(), _showReport.y()); + + _continue.move(width() - padding - _continue.width(), height() - padding - _continue.height()); +} + +NetworkSettingsWindow::NetworkSettingsWindow(QWidget *parent, QString host, quint32 port, QString username, QString password) +: PreLaunchWindow(qsl("HTTP Proxy Settings")) +, _hostLabel(this) +, _portLabel(this) +, _usernameLabel(this) +, _passwordLabel(this) +, _hostInput(this) +, _portInput(this) +, _usernameInput(this) +, _passwordInput(this, true) +, _save(this) +, _cancel(this, false) +, _parent(parent) { + setWindowModality(Qt::ApplicationModal); + + _hostLabel.setText(qsl("Hostname")); + _portLabel.setText(qsl("Port")); + _usernameLabel.setText(qsl("Username")); + _passwordLabel.setText(qsl("Password")); + + _save.setText(qsl("SAVE")); + connect(&_save, SIGNAL(clicked()), this, SLOT(onSave())); + _cancel.setText(qsl("CANCEL")); + connect(&_cancel, SIGNAL(clicked()), this, SLOT(close())); + + _hostInput.setText(host); + _portInput.setText(QString::number(port)); + _usernameInput.setText(username); + _passwordInput.setText(password); + + QRect scr(QApplication::primaryScreen()->availableGeometry()); + move(scr.x() + (scr.width() / 6), scr.y() + (scr.height() / 6)); + updateControls(); + show(); + + _hostInput.setFocus(); + _hostInput.setCursorPosition(_hostInput.text().size()); +} + +void NetworkSettingsWindow::resizeEvent(QResizeEvent *e) { + int padding = _size; + _hostLabel.move(padding, padding); + _hostInput.setGeometry(_hostLabel.x(), _hostLabel.y() + _hostLabel.height(), 2 * _hostLabel.width(), _hostInput.height()); + _portLabel.move(padding + _hostInput.width() + padding, padding); + _portInput.setGeometry(_portLabel.x(), _portLabel.y() + _portLabel.height(), width() - padding - _portLabel.x(), _portInput.height()); + _usernameLabel.move(padding, _hostInput.y() + _hostInput.height() + padding); + _usernameInput.setGeometry(_usernameLabel.x(), _usernameLabel.y() + _usernameLabel.height(), (width() - 3 * padding) / 2, _usernameInput.height()); + _passwordLabel.move(padding + _usernameInput.width() + padding, _usernameLabel.y()); + _passwordInput.setGeometry(_passwordLabel.x(), _passwordLabel.y() + _passwordLabel.height(), width() - padding - _passwordLabel.x(), _passwordInput.height()); + + _save.move(width() - padding - _save.width(), height() - padding - _save.height()); + _cancel.move(_save.x() - padding - _cancel.width(), _save.y()); +} + +void NetworkSettingsWindow::onSave() { + QString host = _hostInput.text().trimmed(), port = _portInput.text().trimmed(), username = _usernameInput.text().trimmed(), password = _passwordInput.text().trimmed(); + if (!port.isEmpty() && !port.toUInt()) { + _portInput.setFocus(); + return; + } else if (!host.isEmpty() && port.isEmpty()) { + _portInput.setFocus(); + return; + } + emit saved(host, port.toUInt(), username, password); + close(); +} + +void NetworkSettingsWindow::closeEvent(QCloseEvent *e) { +} + +void NetworkSettingsWindow::updateControls() { + _hostInput.updateGeometry(); + _hostInput.resize(_hostInput.sizeHint()); + _portInput.updateGeometry(); + _portInput.resize(_portInput.sizeHint()); + _usernameInput.updateGeometry(); + _usernameInput.resize(_usernameInput.sizeHint()); + _passwordInput.updateGeometry(); + _passwordInput.resize(_passwordInput.sizeHint()); + + int padding = _size; + int w = 2 * padding + _hostLabel.width() * 2 + padding + _portLabel.width() * 2 + padding; + int h = padding + _hostLabel.height() + _hostInput.height() + padding + _usernameLabel.height() + _usernameInput.height() + padding + _save.height() + padding; + if (w == width() && h == height()) { + resizeEvent(0); + } else { + setGeometry(_parent->x() + (_parent->width() - w) / 2, _parent->y() + (_parent->height() - h) / 2, w, h); + } +} + +ShowCrashReportWindow::ShowCrashReportWindow(const QString &text) +: _log(this) { + _log.setPlainText(text); QRect scr(QApplication::primaryScreen()->availableGeometry()); setGeometry(scr.x() + (scr.width() / 6), scr.y() + (scr.height() / 6), scr.width() / 2, scr.height() / 2); show(); } -void LastCrashedWindow::closeEvent(QCloseEvent *e) { - deleteLater(); - if (SignalHandlers::restart() == SignalHandlers::CantOpen) { - new NotStartedWindow(); - } else { - new AppClass(); - } -} - -void LastCrashedWindow::resizeEvent(QResizeEvent *e) { - int padding = _label.sizeHint().height() / 2; - _label.setGeometry(padding, padding, width() - 2 * padding, _label.sizeHint().height()); - _log.setGeometry(padding, padding * 2 + _label.sizeHint().height(), width() - 2 * padding, height() - 3 * padding - _label.sizeHint().height()); +void ShowCrashReportWindow::resizeEvent(QResizeEvent *e) { + _log.setGeometry(rect().marginsRemoved(QMargins(basicSize(), basicSize(), basicSize(), basicSize()))); } diff --git a/Telegram/SourceFiles/window.h b/Telegram/SourceFiles/window.h index 535ec3f4e..f7c968ce8 100644 --- a/Telegram/SourceFiles/window.h +++ b/Telegram/SourceFiles/window.h @@ -18,8 +18,7 @@ to link the code of portions of this program with the OpenSSL library. Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE Copyright (c) 2014-2015 John Preston, https://desktop.telegram.org */ -#ifndef MAINWINDOW_H -#define MAINWINDOW_H +#pragma once #include "title.h" #include "pspecific.h" @@ -353,7 +352,47 @@ private: MediaView *_mediaView; }; -class NotStartedWindow : public TWidget { +class PreLaunchWindow : public TWidget { +public: + + PreLaunchWindow(QString title = QString()); + void activate(); + float64 basicSize() const { + return _size; + } + ~PreLaunchWindow(); + + static PreLaunchWindow *instance(); + +protected: + + float64 _size; + +}; + +class PreLaunchLabel : public QLabel { +public: + PreLaunchLabel(QWidget *parent); + void setText(const QString &text); +}; + +class PreLaunchInput : public QLineEdit { +public: + PreLaunchInput(QWidget *parent, bool password = false); +}; + +class PreLaunchLog : public QTextEdit { +public: + PreLaunchLog(QWidget *parent); +}; + +class PreLaunchButton : public QPushButton { +public: + PreLaunchButton(QWidget *parent, bool confirm = true); + void setText(const QString &text); +}; + +class NotStartedWindow : public PreLaunchWindow { public: NotStartedWindow(); @@ -365,16 +404,48 @@ protected: private: - QLabel _label; - QTextEdit _log; + void updateControls(); + + PreLaunchLabel _label; + PreLaunchLog _log; + PreLaunchButton _close; }; -class LastCrashedWindow : public TWidget { +class LastCrashedWindow : public PreLaunchWindow { + Q_OBJECT + public: LastCrashedWindow(); +public slots: + + void onViewReport(); + void onSaveReport(); + void onSendReport(); + void onGetApp(); + + void onNetworkSettings(); + void onNetworkSettingsSaved(QString host, quint32 port, QString username, QString password); + void onContinue(); + + void onCheckingFinished(); + void onSendingError(QNetworkReply::NetworkError e); + void onSendingFinished(); + void onSendingProgress(qint64 uploaded, qint64 total); + +#ifndef TDESKTOP_DISABLE_AUTOUPDATE + void onUpdateRetry(); + void onUpdateSkip(); + + void onUpdateChecking(); + void onUpdateLatest(); + void onUpdateDownloading(qint64 ready, qint64 total); + void onUpdateReady(); + void onUpdateFailed(); +#endif + protected: void closeEvent(QCloseEvent *e); @@ -382,10 +453,103 @@ protected: private: - QLabel _label; - QTextEdit _log; - QPushButton _send; + void updateControls(); + + QString _host, _username, _password; + quint32 _port; + + PreLaunchLabel _label, _pleaseSendReport, _minidump; + PreLaunchLog _report; + PreLaunchButton _send, _sendSkip, _networkSettings, _continue, _showReport, _saveReport, _getApp; + + QString _minidumpName, _minidumpFull, _reportText; + bool _reportShown, _reportSaved; + + enum SendingState { + SendingNoReport, + SendingUpdateCheck, + SendingNone, + SendingTooOld, + SendingTooMany, + SendingUnofficial, + SendingProgress, + SendingUploading, + SendingFail, + SendingDone, + }; + SendingState _sendingState; + + PreLaunchLabel _updating; + qint64 _sendingProgress, _sendingTotal; + + QNetworkAccessManager _sendManager; + QNetworkReply *_checkReply, *_sendReply; + +#ifndef TDESKTOP_DISABLE_AUTOUPDATE + PreLaunchButton _updatingCheck, _updatingSkip; + enum UpdatingState { + UpdatingNone, + UpdatingCheck, + UpdatingLatest, + UpdatingDownload, + UpdatingFail, + UpdatingReady + }; + UpdatingState _updatingState; + QString _newVersionDownload; + + void setUpdatingState(UpdatingState state, bool force = false); + void setDownloadProgress(qint64 ready, qint64 total); +#endif + + QString getReportField(const QLatin1String &name, const QLatin1String &prefix); + void addReportFieldPart(const QLatin1String &name, const QLatin1String &prefix, QHttpMultiPart *multipart); }; -#endif // MAINWINDOW_H +class NetworkSettingsWindow : public PreLaunchWindow { + Q_OBJECT + +public: + + NetworkSettingsWindow(QWidget *parent, QString host, quint32 port, QString username, QString password); + +signals: + + void saved(QString host, quint32 port, QString username, QString password); + +public slots: + + void onSave(); + +protected: + + void closeEvent(QCloseEvent *e); + void resizeEvent(QResizeEvent *e); + +private: + + void updateControls(); + + PreLaunchLabel _hostLabel, _portLabel, _usernameLabel, _passwordLabel; + PreLaunchInput _hostInput, _portInput, _usernameInput, _passwordInput; + PreLaunchButton _save, _cancel; + + QWidget *_parent; + +}; + +class ShowCrashReportWindow : public PreLaunchWindow { +public: + + ShowCrashReportWindow(const QString &text); + +protected: + + void resizeEvent(QResizeEvent *e); + +private: + + PreLaunchLog _log; + +}; diff --git a/Telegram/Telegram.vcxproj b/Telegram/Telegram.vcxproj index 5530f46a4..44ffbe14d 100644 --- a/Telegram/Telegram.vcxproj +++ b/Telegram/Telegram.vcxproj @@ -1053,8 +1053,14 @@ + + NotUsing + + + + $(QTDIR)\bin\moc.exe;%(FullPath) Moc%27ing types.h... @@ -1630,7 +1636,7 @@ "$(QTDIR)\bin\moc.exe" "%(FullPath)" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp" -DAL_LIBTYPE_STATIC -DCUSTOM_API_ID -DUNICODE -DWIN32 -DWIN64 -DHAVE_STDINT_H -DZLIB_WINAPI -DQT_NO_DEBUG -DNDEBUG -D_SCL_SECURE_NO_WARNINGS "-I.\..\..\Libraries\lzma\C" "-I.\..\..\Libraries\libexif-0.6.20" "-I.\..\..\Libraries\zlib-1.2.8" "-I.\..\..\Libraries\openssl\Release\include" "-I.\..\..\Libraries\ffmpeg" "-I.\..\..\Libraries\openal-soft\include" "-I.\SourceFiles" "-I.\GeneratedFiles" "-I." "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I.\..\..\Libraries\QtStatic\qtbase\include\QtCore\5.5.1\QtCore" "-I.\..\..\Libraries\QtStatic\qtbase\include\QtGui\5.5.1\QtGui" "-fstdafx.h" "-f../../SourceFiles/history.h" Moc%27ing history.h... .\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp - "$(QTDIR)\bin\moc.exe" "%(FullPath)" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp" "-fstdafx.h" "-f../../SourceFiles/history.h" -DAL_LIBTYPE_STATIC -DUNICODE -DWIN32 -DWIN64 -DHAVE_STDINT_H -DZLIB_WINAPI -D_SCL_SECURE_NO_WARNINGS "-I.\..\..\Libraries\lzma\C" "-I.\..\..\Libraries\libexif-0.6.20" "-I.\..\..\Libraries\zlib-1.2.8" "-I.\..\..\Libraries\openssl_debug\Debug\include" "-I.\..\..\Libraries\ffmpeg" "-I.\..\..\Libraries\openal-soft\include" "-I.\SourceFiles" "-I.\GeneratedFiles" "-I." "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I.\..\..\Libraries\QtStatic\qtbase\include\QtCore\5.5.1\QtCore" "-I.\..\..\Libraries\QtStatic\qtbase\include\QtGui\5.5.1\QtGui" + "$(QTDIR)\bin\moc.exe" "%(FullPath)" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp" -DAL_LIBTYPE_STATIC -DUNICODE -DWIN32 -DWIN64 -DHAVE_STDINT_H -DZLIB_WINAPI -D_SCL_SECURE_NO_WARNINGS "-I.\..\..\Libraries\lzma\C" "-I.\..\..\Libraries\libexif-0.6.20" "-I.\..\..\Libraries\zlib-1.2.8" "-I.\..\..\Libraries\openssl_debug\Debug\include" "-I.\..\..\Libraries\ffmpeg" "-I.\..\..\Libraries\openal-soft\include" "-I.\SourceFiles" "-I.\GeneratedFiles" "-I." "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I.\..\..\Libraries\QtStatic\qtbase\include\QtCore\5.5.1\QtCore" "-I.\..\..\Libraries\QtStatic\qtbase\include\QtGui\5.5.1\QtGui" "-fstdafx.h" "-f../../SourceFiles/history.h" Moc%27ing history.h... .\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp "$(QTDIR)\bin\moc.exe" "%(FullPath)" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp" -DAL_LIBTYPE_STATIC -DUNICODE -DWIN32 -DWIN64 -DHAVE_STDINT_H -DZLIB_WINAPI -DQT_NO_DEBUG -DNDEBUG -D_SCL_SECURE_NO_WARNINGS "-I.\..\..\Libraries\lzma\C" "-I.\..\..\Libraries\libexif-0.6.20" "-I.\..\..\Libraries\zlib-1.2.8" "-I.\..\..\Libraries\openssl\Release\include" "-I.\..\..\Libraries\ffmpeg" "-I.\..\..\Libraries\openal-soft\include" "-I.\SourceFiles" "-I.\GeneratedFiles" "-I." "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I.\..\..\Libraries\QtStatic\qtbase\include\QtCore\5.5.1\QtCore" "-I.\..\..\Libraries\QtStatic\qtbase\include\QtGui\5.5.1\QtGui" "-fstdafx.h" "-f../../SourceFiles/history.h" diff --git a/Telegram/Telegram.vcxproj.filters b/Telegram/Telegram.vcxproj.filters index a5652079e..f58dc5f42 100644 --- a/Telegram/Telegram.vcxproj.filters +++ b/Telegram/Telegram.vcxproj.filters @@ -897,6 +897,9 @@ Generated Files\Release + + Generated Files + @@ -986,6 +989,15 @@ Source Files + + Generated Files + + + Generated Files + + + Generated Files +