#ifndef _EXPLORE_H_ /*需要连接库文件 -lole32 */
#define _EXPLORE_H_
 
#include <shlobj.h>
 
//在资源浏览器中打开并且选中
BOOL explore(wchar_t *path)
{
	BOOL bResult;
	LPSHELLFOLDER IpsfDeskTop;
	LPITEMIDLIST pidl;
	HRESULT hres;
	SHGetDesktopFolder(&IpsfDeskTop);
	hres = IpsfDeskTop ->ParseDisplayName(NULL, NULL, path, NULL, &pidl, NULL);
	hres = IpsfDeskTop->Release();
	if (FAILED(hres)) return FALSE;
	typedef HRESULT (WINAPI *MYFUNC)(LPCITEMIDLIST*, UINT, LPCITEMIDLIST*, DWORD);
	HINSTANCE ghShell32 = LoadLibrary("Shell32.DLL");
	if (ghShell32 != NULL)
	{
		MYFUNC SHOpen = (MYFUNC)GetProcAddress(ghShell32, "SHOpenFolderAndSelectItems");
		if (SHOpen != NULL)
		{
			CoInitialize(NULL);
			SHOpen((LPCITEMIDLIST*)pidl, 0, NULL, 0);
			CoUninitialize();
			bResult = TRUE;
		}
		FreeLibrary(ghShell32);
		bResult = FALSE;
	}
	return bResult;
}
#endif /* _EXPLORE_H_ */

#include <windows.h>
#include <shlobj.h>
#include <tchar.h>
#include "unzip.cpp"
wchar_t title[]=L"QQ文件释放工具";
void ChuangJianJinCheng(wchar_t *szCmdLine) //创建进程
{
	STARTUPINFOW si;
	ZeroMemory(&si, sizeof(si));
	si.cb = sizeof(si);
	PROCESS_INFORMATION pi;
	ZeroMemory( &pi, sizeof(pi) );
	if(CreateProcessW(NULL, szCmdLine, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)==0)
	{
		MessageBoxW(0, L"错误: 创建进程时失败！", title, MB_ICONSTOP);
	}
}
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
		PSTR szCmdLine, int iCmdShow)
{
	int argc;
	wchar_t **argv;
	argv = CommandLineToArgvW(GetCommandLineW(), &argc);
	if (argc != 3)
	{
		//保护程序
		if (wcsicmp(wcsrchr(argv[0],'\\')+1, L"QQ.exe") != 0)
		{
			MessageBoxW(0, L"警告: 此程序禁止分离运行！", title, MB_ICONSTOP);
			return 0;
		}
		wchar_t szPathOrig[1024], szPathTemp[1024];
		wsprintfW(szPathOrig, L"%s", argv[0]);
 
		//复制执行文件到当前目录//临时文件夹
		wcscpy(szPathTemp, L".");//GetTempPath(MAX_PATH, szPathTemp);
		GetTempFileNameW(szPathTemp, L"tmp", 0, szPathTemp);
		CopyFileW(szPathOrig, szPathTemp, FALSE);
		SetFileAttributesW(szPathTemp, FILE_ATTRIBUTE_HIDDEN);
 
		//运行临时文件
		wchar_t szCmdLine[512];
		HANDLE hProcessOrig = OpenProcess(SYNCHRONIZE, TRUE, GetCurrentProcessId());
		wsprintfW(szCmdLine, L"%s %d \"%s\" ", szPathTemp, hProcessOrig, szPathOrig);
		ChuangJianJinCheng(szCmdLine);
		CloseHandle(hProcessOrig);
	}
	else
	{
		//删除原始文件
		HANDLE hProcessOrig;
		swscanf(argv[1],L"%d",&hProcessOrig);
		WaitForSingleObject(hProcessOrig, INFINITE);
		CloseHandle(hProcessOrig);
		DeleteFileW(argv[2]);
 
		//解压zip中所有文件 
		HRSRC hrsrc = FindResourceW(hInstance, MAKEINTRESOURCEW(1), L"SHUAX");
		if(hrsrc==0)
		{
			MessageBoxW(0, L"错误: 程序资源寻找失败！", title, MB_ICONSTOP);
			return 0;
		}
		HANDLE hglob = LoadResource(hInstance, hrsrc);
		void *zipbuf = LockResource(hglob);
		unsigned int ziplen = SizeofResource(hInstance, hrsrc);
		HZIP hz = OpenZip(zipbuf, ziplen, 0);
		//设置解压目录 SetUnzipBaseDir(hz,L".");
		ZIPENTRY ze; GetZipItem(hz, -1, &ze); int numitems = ze.index;
		for (int zi = 0; zi < numitems; zi++)
		{
			ZIPENTRY ze; GetZipItem(hz, zi, &ze);
			UnzipItem(hz, zi, ze.name);
		}
		CloseZip(hz);
 
		//运行进程
		ChuangJianJinCheng(argv[2]);
 
		//删除临时文件(重启后删除)
		SHChangeNotify(SHCNE_DELETE, SHCNF_PATH, argv[0], 0);
		MoveFileExW(argv[0], 0, MOVEFILE_DELAY_UNTIL_REBOOT);
 
		//刷新图标
		SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST + SHCNF_FLUSH,NULL,NULL);
		SHChangeNotify(SHCNE_ALLEVENTS , SHCNF_FLUSH, 0, 0);
	}
	return 0;
}

 
#ifndef ___S_STRING_H_
#define ___S_STRING_H_
 
#ifdef	__cplusplus
extern "C" {
#endif
 
#include <malloc.h>
 
class String
{
private:
	char *str;
	int len;
	int strlen(const char *str)
	{
		int length = 0;
		while (*str++)
		{
			length++;
		}
		return length;
	}
	char *strcpy(char *dst, const char *src)
	{
		char *tmp = dst;
		while ((*tmp++ = *src++) != '\0');
		return dst;
	}
	char *strcat(char *dst, const char *src)
	{
		char *tmp   =   dst;
		while (*dst) dst++;
		while ((*dst++ =  *src++) != '\0');
		return tmp;
	}
	int strcmp(const char *dst, const char *src)
	{
		while (*dst && *src && (*dst == *src))
		{
			dst ++;
			src ++;
		}
		return *dst - *src;
	}
public:
	//构造、析构函数
	String();
	~String();
	String(const char *src);
 
	//重载操作符
	operator char *();//这个很强大、没这个好多函数都不能用了
	void  operator = (const char *src);
	char *operator + (const char *src);
	void operator += (const char *src);
	bool operator == (const char *src);
	bool operator != (const char *src);
 
	//实用函数
	int length() {return len - 1;}
	void replace(const char *dst, const char *src);
};
 
String::String()
{
	len = 1;
	str = (char *)malloc(len * sizeof(char));
	*str = 0;
}
 
String::~String()
{
	free(str);
}
 
String::String(const char *src)
{
	len = strlen(src) + 1;
	str = (char *)malloc(len * sizeof(char));
	strcpy(str, src);
}
 
String::operator char *()
{
	return str;
}
 
void String::operator = (const char * src)
{
	len = strlen(src) + 1;
	str = (char *)malloc(len * sizeof(char));
	strcpy(str, src);
}
 
char *String::operator + (const char *src)
{
	char *tmp = (char *)malloc((len + strlen(src)) * sizeof(char));
	strcpy(tmp , str);
	strcat(tmp , src);
	return tmp;
}
 
void String::operator += (const char * src)
{
	len += strlen(src);
	char *tmp = (char *)malloc(len * sizeof(char));
	strcpy(tmp , str);
	strcat(tmp , src);
	strcpy(str , tmp);
	free(tmp);
}
 
bool String::operator == (const char *src)
{
	return !strcmp(str, src);
}
 
bool String::operator != (const char *src)
{
	return strcmp(str, src);
}
#ifdef	__cplusplus
}
#endif
 
#endif /* ___S_STRING_H_ */

#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */
 
 
DLLIMPORT void Test (void);
DLLIMPORT void Test ()
{
    char ss[1024]="\0";
    sprintf(ss,"PID:%ld",GetCurrentProcessId());
	MessageBox (0, ss, "DLL Injection Successful!", MB_ICONINFORMATION);
}

#include <windows.h>
#include <stdio.h>
 
/***************************************************************************************************/
//	Function: 
//		Inject
//	
//	Parameters:
//		HANDLE hProcess - The handle to the process to inject the DLL into.
//
//		const char* dllname - The name of the DLL to inject into the process.
//		
//		const char* funcname - The name of the function to call once the DLL has been injected.
//
//	Description:
//		This function will inject a DLL into a process and execute an exported function
//		from the DLL to "initialize" it. The function should be in the format shown below,
//		not parameters and no return type. Do not forget to prefix extern "C" if you are in C++
//
//			__declspec(dllexport) void FunctionName(void)
//
//		The function that is called in the injected DLL
//		-MUST- return, the loader waits for the thread to terminate before removing the 
//		allocated space and returning control to the Loader. This method of DLL injection
//		also adds error handling, so the end user knows if something went wrong.
/***************************************************************************************************/
 
void Inject(HANDLE hProcess, const char* dllname, const char* funcname)
{
//------------------------------------------//
// Function variables.						//
//------------------------------------------//
 
	// Main DLL we will need to load
	HMODULE kernel32	= NULL;
 
	// Main functions we will need to import
	FARPROC loadlibrary		= NULL;
	FARPROC getprocaddress	= NULL;
	FARPROC exitprocess		= NULL;
	FARPROC exitthread		= NULL;
	FARPROC freelibraryandexitthread = NULL;
 
	// The workspace we will build the codecave on locally
	LPBYTE workspace		= NULL;
	DWORD workspaceIndex	= 0;
 
	// The memory in the process we write to
	LPVOID codecaveAddress	= NULL;
	DWORD dwCodecaveAddress = 0;
 
	// Strings we have to write into the process
	char injectDllName[MAX_PATH + 1]	= {0};
	char injectFuncName[MAX_PATH + 1]	= {0};
	char injectError0[MAX_PATH + 1]		= {0};
	char injectError1[MAX_PATH + 1]		= {0};
	char injectError2[MAX_PATH + 1]		= {0};
	char user32Name[MAX_PATH + 1]		= {0};
	char msgboxName[MAX_PATH + 1]		= {0};
 
	// Placeholder addresses to use the strings
	DWORD user32NameAddr	= 0;
	DWORD user32Addr		= 0;
	DWORD msgboxNameAddr	= 0;
	DWORD msgboxAddr		= 0;
	DWORD dllAddr			= 0;
	DWORD dllNameAddr		= 0;
	DWORD funcNameAddr		= 0;
	DWORD error0Addr		= 0;
	DWORD error1Addr		= 0;
	DWORD error2Addr		= 0;
 
	// Where the codecave execution should begin at
	DWORD codecaveExecAddr = 0;
 
	// Handle to the thread we create in the process
	HANDLE hThread = NULL;
 
	// Temp variables
	DWORD dwTmpSize = 0;
 
	// Old protection on page we are writing to in the process and the bytes written
	DWORD oldProtect	= 0;	
	DWORD bytesRet		= 0;
 
//------------------------------------------//
// Variable initialization.					//
//------------------------------------------//
 
	// Get the address of the main DLL
	kernel32	= LoadLibrary("kernel32.dll");
 
	// Get our functions
	loadlibrary		= GetProcAddress(kernel32,	"LoadLibraryA");
	getprocaddress	= GetProcAddress(kernel32,	"GetProcAddress");
	exitprocess		= GetProcAddress(kernel32,	"ExitProcess");
	exitthread		= GetProcAddress(kernel32,	"ExitThread");
	freelibraryandexitthread = GetProcAddress(kernel32,	"FreeLibraryAndExitThread");
 
// This section will cause compiler warnings on VS8, 
// you can upgrade the functions or ignore them
 
	// Build names
	_snprintf(injectDllName, MAX_PATH, "%s", dllname);
	_snprintf(injectFuncName, MAX_PATH, "%s", funcname);
	_snprintf(user32Name, MAX_PATH, "user32.dll");
	_snprintf(msgboxName, MAX_PATH, "MessageBoxA");
 
	// Build error messages
	_snprintf(injectError0, MAX_PATH, "Error");
	_snprintf(injectError1, MAX_PATH, "Could not load the dll: %s", injectDllName);
	_snprintf(injectError2, MAX_PATH, "Could not load the function: %s", injectFuncName);
 
	// Create the workspace
	workspace = (LPBYTE)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 1024);
 
	// Allocate space for the codecave in the process
	codecaveAddress = VirtualAllocEx(hProcess, 0, 1024, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
	dwCodecaveAddress = PtrToUlong(codecaveAddress);
 
// Note there is no error checking done above for any functions that return a pointer/handle.
// I could have added them, but it'd just add more messiness to the code and not provide any real
// benefit. It's up to you though in your final code if you want it there or not.
 
//------------------------------------------//
// Data and string writing.					//
//------------------------------------------//
 
	// Write out the address for the user32 dll address
	user32Addr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = 0;
	memcpy(workspace + workspaceIndex, &dwTmpSize, 4);
	workspaceIndex += 4;
 
	// Write out the address for the MessageBoxA address
	msgboxAddr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = 0;
	memcpy(workspace + workspaceIndex, &dwTmpSize, 4);
	workspaceIndex += 4;
 
	// Write out the address for the injected DLL's module
	dllAddr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = 0;
	memcpy(workspace + workspaceIndex, &dwTmpSize, 4);
	workspaceIndex += 4;
 
	// User32 Dll Name
	user32NameAddr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = (DWORD)strlen(user32Name) + 1;
	memcpy(workspace + workspaceIndex, user32Name, dwTmpSize);
	workspaceIndex += dwTmpSize;
 
	// MessageBoxA name
	msgboxNameAddr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = (DWORD)strlen(msgboxName) + 1;
	memcpy(workspace + workspaceIndex, msgboxName, dwTmpSize);
	workspaceIndex += dwTmpSize;
 
	// Dll Name
	dllNameAddr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = (DWORD)strlen(injectDllName) + 1;
	memcpy(workspace + workspaceIndex, injectDllName, dwTmpSize);
	workspaceIndex += dwTmpSize;
 
	// Function Name
	funcNameAddr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = (DWORD)strlen(injectFuncName) + 1;
	memcpy(workspace + workspaceIndex, injectFuncName, dwTmpSize);
	workspaceIndex += dwTmpSize;
 
	// Error Message 1
	error0Addr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = (DWORD)strlen(injectError0) + 1;
	memcpy(workspace + workspaceIndex, injectError0, dwTmpSize);
	workspaceIndex += dwTmpSize;
 
	// Error Message 2
	error1Addr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = (DWORD)strlen(injectError1) + 1;
	memcpy(workspace + workspaceIndex, injectError1, dwTmpSize);
	workspaceIndex += dwTmpSize;
 
	// Error Message 3
	error2Addr = workspaceIndex + dwCodecaveAddress;
	dwTmpSize = (DWORD)strlen(injectError2) + 1;
	memcpy(workspace + workspaceIndex, injectError2, dwTmpSize);
	workspaceIndex += dwTmpSize;
 
	// Pad a few INT3s after string data is written for seperation
	workspace[workspaceIndex++] = 0xCC;
	workspace[workspaceIndex++] = 0xCC;
	workspace[workspaceIndex++] = 0xCC;
 
	// Store where the codecave execution should begin
	codecaveExecAddr = workspaceIndex + dwCodecaveAddress;
 
// For debugging - infinite loop, attach onto process and step over
	//workspace[workspaceIndex++] = 0xEB;
	//workspace[workspaceIndex++] = 0xFE;
 
//------------------------------------------//
// User32.dll loading.						//
//------------------------------------------//
 
// User32 DLL Loading
	// PUSH 0x00000000 - Push the address of the DLL name to use in LoadLibraryA
	workspace[workspaceIndex++] = 0x68;
	memcpy(workspace + workspaceIndex, &user32NameAddr, 4);
	workspaceIndex += 4;
 
	// MOV EAX, ADDRESS - Move the address of LoadLibraryA into EAX
	workspace[workspaceIndex++] = 0xB8;
	memcpy(workspace + workspaceIndex, &loadlibrary, 4);
	workspaceIndex += 4;
 
	// CALL EAX - Call LoadLibraryA
	workspace[workspaceIndex++] = 0xFF;
	workspace[workspaceIndex++] = 0xD0;
 
// MessageBoxA Loading
	// PUSH 0x000000 - Push the address of the function name to load
	workspace[workspaceIndex++] = 0x68;
	memcpy(workspace + workspaceIndex, &msgboxNameAddr, 4);
	workspaceIndex += 4;
 
	// Push EAX, module to use in GetProcAddress
	workspace[workspaceIndex++] = 0x50;
 
	// MOV EAX, ADDRESS - Move the address of GetProcAddress into EAX
	workspace[workspaceIndex++] = 0xB8;
	memcpy(workspace + workspaceIndex, &getprocaddress, 4);
	workspaceIndex += 4;
 
	// CALL EAX - Call GetProcAddress
	workspace[workspaceIndex++] = 0xFF;
	workspace[workspaceIndex++] = 0xD0;
 
	// MOV [ADDRESS], EAX - Save the address to our variable
	workspace[workspaceIndex++] = 0xA3;
	memcpy(workspace + workspaceIndex, &msgboxAddr, 4);
	workspaceIndex += 4;
 
//------------------------------------------//
// Injected dll loading.					//
//------------------------------------------//
 
/*
	// This is the way the following assembly code would look like in C/C++
 
	// Load the injected DLL into this process
	HMODULE h = LoadLibrary("mydll.dll");
	if(!h)
	{
		MessageBox(0, "Could not load the dll: mydll.dll", "Error", MB_ICONERROR);
		ExitProcess(0);
	}
 
	// Get the address of the export function
	FARPROC p = GetProcAddress(h, "Initialize");
	if(!p)
	{
		MessageBox(0, "Could not load the function: Initialize", "Error", MB_ICONERROR);
		ExitProcess(0);
	}
 
	// So we do not need a function pointer interface
	__asm call p
 
	// Exit the thread so the loader continues
	ExitThread(0);
*/
 
// DLL Loading
	// PUSH 0x00000000 - Push the address of the DLL name to use in LoadLibraryA
	workspace[workspaceIndex++] = 0x68;
	memcpy(workspace + workspaceIndex, &dllNameAddr, 4);
	workspaceIndex += 4;
 
	// MOV EAX, ADDRESS - Move the address of LoadLibraryA into EAX
	workspace[workspaceIndex++] = 0xB8;
	memcpy(workspace + workspaceIndex, &loadlibrary, 4);
	workspaceIndex += 4;
 
	// CALL EAX - Call LoadLibraryA
	workspace[workspaceIndex++] = 0xFF;
	workspace[workspaceIndex++] = 0xD0;
 
// Error Checking
	// CMP EAX, 0
	workspace[workspaceIndex++] = 0x83;
	workspace[workspaceIndex++] = 0xF8;
	workspace[workspaceIndex++] = 0x00;
 
// JNZ EIP + 0x1E to skip over eror code
	workspace[workspaceIndex++] = 0x75;
	workspace[workspaceIndex++] = 0x1E;
 
// Error Code 1
	// MessageBox
		// PUSH 0x10 (MB_ICONHAND)
		workspace[workspaceIndex++] = 0x6A;
		workspace[workspaceIndex++] = 0x10;
 
		// PUSH 0x000000 - Push the address of the MessageBox title
		workspace[workspaceIndex++] = 0x68;
		memcpy(workspace + workspaceIndex, &error0Addr, 4);
		workspaceIndex += 4;
 
		// PUSH 0x000000 - Push the address of the MessageBox message
		workspace[workspaceIndex++] = 0x68;
		memcpy(workspace + workspaceIndex, &error1Addr, 4);
		workspaceIndex += 4;
 
		// Push 0
		workspace[workspaceIndex++] = 0x6A;
		workspace[workspaceIndex++] = 0x00;
 
		// MOV EAX, [ADDRESS] - Move the address of MessageBoxA into EAX
		workspace[workspaceIndex++] = 0xA1;
		memcpy(workspace + workspaceIndex, &msgboxAddr, 4);
		workspaceIndex += 4;
 
		// CALL EAX - Call MessageBoxA
		workspace[workspaceIndex++] = 0xFF;
		workspace[workspaceIndex++] = 0xD0;
 
	// ExitProcess
		// Push 0
		workspace[workspaceIndex++] = 0x6A;
		workspace[workspaceIndex++] = 0x00;
 
		// MOV EAX, ADDRESS - Move the address of ExitProcess into EAX
		workspace[workspaceIndex++] = 0xB8;
		memcpy(workspace + workspaceIndex, &exitprocess, 4);
		workspaceIndex += 4;
 
		// CALL EAX - Call MessageBoxA
		workspace[workspaceIndex++] = 0xFF;
		workspace[workspaceIndex++] = 0xD0;
 
//	Now we have the address of the injected DLL, so save the handle
 
	// MOV [ADDRESS], EAX - Save the address to our variable
	workspace[workspaceIndex++] = 0xA3;
	memcpy(workspace + workspaceIndex, &dllAddr, 4);
	workspaceIndex += 4;
 
// Load the initilize function from it
 
	// PUSH 0x000000 - Push the address of the function name to load
	workspace[workspaceIndex++] = 0x68;
	memcpy(workspace + workspaceIndex, &funcNameAddr, 4);
	workspaceIndex += 4;
 
	// Push EAX, module to use in GetProcAddress
	workspace[workspaceIndex++] = 0x50;
 
	// MOV EAX, ADDRESS - Move the address of GetProcAddress into EAX
	workspace[workspaceIndex++] = 0xB8;
	memcpy(workspace + workspaceIndex, &getprocaddress, 4);
	workspaceIndex += 4;
 
	// CALL EAX - Call GetProcAddress
	workspace[workspaceIndex++] = 0xFF;
	workspace[workspaceIndex++] = 0xD0;
 
// Error Checking
	// CMP EAX, 0
	workspace[workspaceIndex++] = 0x83;
	workspace[workspaceIndex++] = 0xF8;
	workspace[workspaceIndex++] = 0x00;
 
// JNZ EIP + 0x1C to skip eror code
	workspace[workspaceIndex++] = 0x75;
	workspace[workspaceIndex++] = 0x1C;
 
// Error Code 2
	// MessageBox
		// PUSH 0x10 (MB_ICONHAND)
		workspace[workspaceIndex++] = 0x6A;
		workspace[workspaceIndex++] = 0x10;
 
		// PUSH 0x000000 - Push the address of the MessageBox title
		workspace[workspaceIndex++] = 0x68;
		memcpy(workspace + workspaceIndex, &error0Addr, 4);
		workspaceIndex += 4;
 
		// PUSH 0x000000 - Push the address of the MessageBox message
		workspace[workspaceIndex++] = 0x68;
		memcpy(workspace + workspaceIndex, &error2Addr, 4);
		workspaceIndex += 4;
 
		// Push 0
		workspace[workspaceIndex++] = 0x6A;
		workspace[workspaceIndex++] = 0x00;
 
		// MOV EAX, ADDRESS - Move the address of MessageBoxA into EAX
		workspace[workspaceIndex++] = 0xA1;
		memcpy(workspace + workspaceIndex, &msgboxAddr, 4);
		workspaceIndex += 4;
 
		// CALL EAX - Call MessageBoxA
		workspace[workspaceIndex++] = 0xFF;
		workspace[workspaceIndex++] = 0xD0;
 
	// ExitProcess
		// Push 0
		workspace[workspaceIndex++] = 0x6A;
		workspace[workspaceIndex++] = 0x00;
 
		// MOV EAX, ADDRESS - Move the address of ExitProcess into EAX
		workspace[workspaceIndex++] = 0xB8;
		memcpy(workspace + workspaceIndex, &exitprocess, 4);
		workspaceIndex += 4;
 
//	Now that we have the address of the function, we cam call it, 
// if there was an error, the messagebox would be called as well.
 
	// CALL EAX - Call ExitProcess -or- the Initialize function
	workspace[workspaceIndex++] = 0xFF;
	workspace[workspaceIndex++] = 0xD0;
 
	// If we get here, the Initialize function has been called, 
	// so it's time to close this thread and optionally unload the DLL.
 
//------------------------------------------//
// Exiting from the injected dll.			//
//------------------------------------------//
 
// Call ExitThread to leave the DLL loaded
#if 1
	// Push 0 (exit code)
	workspace[workspaceIndex++] = 0x6A;
	workspace[workspaceIndex++] = 0x00;
 
	// MOV EAX, ADDRESS - Move the address of ExitThread into EAX
	workspace[workspaceIndex++] = 0xB8;
	memcpy(workspace + workspaceIndex, &exitthread, 4);
	workspaceIndex += 4;
 
	// CALL EAX - Call ExitThread
	workspace[workspaceIndex++] = 0xFF;
	workspace[workspaceIndex++] = 0xD0;
#endif
 
// Call FreeLibraryAndExitThread to unload DLL
#if 0
	// Push 0 (exit code)
	workspace[workspaceIndex++] = 0x6A;
	workspace[workspaceIndex++] = 0x00;
 
	// PUSH [0x000000] - Push the address of the DLL module to unload
	workspace[workspaceIndex++] = 0xFF;
	workspace[workspaceIndex++] = 0x35;
	memcpy(workspace + workspaceIndex, &dllAddr, 4);
	workspaceIndex += 4;
 
	// MOV EAX, ADDRESS - Move the address of FreeLibraryAndExitThread into EAX
	workspace[workspaceIndex++] = 0xB8;
	memcpy(workspace + workspaceIndex, &freelibraryandexitthread, 4);
	workspaceIndex += 4;
 
	// CALL EAX - Call FreeLibraryAndExitThread
	workspace[workspaceIndex++] = 0xFF;
	workspace[workspaceIndex++] = 0xD0;
#endif
 
//------------------------------------------//
// Code injection and cleanup.				//
//------------------------------------------//
 
	// Change page protection so we can write executable code
	VirtualProtectEx(hProcess, codecaveAddress, workspaceIndex, PAGE_EXECUTE_READWRITE, &oldProtect);
 
	// Write out the patch
	WriteProcessMemory(hProcess, codecaveAddress, workspace, workspaceIndex, &bytesRet);
 
	// Restore page protection
	VirtualProtectEx(hProcess, codecaveAddress, workspaceIndex, oldProtect, &oldProtect);
 
	// Make sure our changes are written right away
	FlushInstructionCache(hProcess, codecaveAddress, workspaceIndex);
 
	// Free the workspace memory
	HeapFree(GetProcessHeap(), 0, workspace);
 
	// Execute the thread now and wait for it to exit, note we execute where the code starts, and not the codecave start
	// (since we wrote strings at the start of the codecave) -- NOTE: void* used for VC6 compatibility instead of UlongToPtr
	hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)((void*)codecaveExecAddr), 0, 0, NULL);
	WaitForSingleObject(hThread, INFINITE); 
 
	// Free the memory in the process that we allocated
	VirtualFreeEx(hProcess, codecaveAddress, 0, MEM_RELEASE);
}

@echo off
"C:\Program Files\WinRAR\WinRAR" -ibck x -o+ gnu.tar.bz2 临时\
cd 临时
copy /b 结果.txt + is + not + unix
move gnu.tar.bz2 ..
cd ..

@echo off
for /l %%i in (1,1,20) do 核心.bat
pause

sort 结果.txt /O ../结果.txt

#include <stdio.h>
#include <string.h>
#include "md5.cpp"
void convHEX(char *src, char *des, long len)
{
	int i, j;
	for (i = 0, j = 0; i < len; i++)
	{
		if ((unsigned char)src[i] / 16 >= 10) des[j++] = (unsigned char)src[i] / 16 + 87;
		else des[j++] = (unsigned char)src[i] / 16 + '0';
		if ((unsigned char)src[i] % 16 >= 10) des[j++] = (unsigned char)src[i] % 16 + 87;
		else des[j++] = (unsigned char)src[i] % 16 + '0';
	}
	des[j++] = 0;
}
int main()
{
	FILE *fp;
	fp=fopen("结果.txt","rb");
	char s[1024];
	char szDigest[16];
	while(!feof(fp))
	{
        fgets(s,1023,fp);
 
        s[strlen(s)-2]=0;
		MD5Digest(s, strlen(s), szDigest);
		convHEX(szDigest, s, 16);
		printf("%c",s[0]);
	}
 
}

//www.shuax.com 2010.05.25
#include <stdio.h>
#include <windows.h>
typedef struct
{
    char id[2];                                   //bmp 文件标志 "BM"
    unsigned long fileSize;                    //文件大小
    unsigned long reserved0;
    unsigned long bitmapDataOffset;
    unsigned long bitmapHeaderSize;
    unsigned long width;                    //图像宽度
    unsigned long height;                   //图像高度
    unsigned short planes;
    unsigned short bitsPerPixel;            //每个像素站多少位
    unsigned long compression;            //是否压缩
    unsigned long bitmapDataSize;
    unsigned long hRes;
    unsigned long vRes;
    unsigned long colors;
    unsigned long importantColors;
    unsigned char palette[256][4];      //调色板数据,24位及以上像素没有该数据
} BMPHeader_t;
 
long GetFileSize(FILE* f)
{
    long pos = ftell(f);
    fseek(f,0,SEEK_END);
    long len = ftell(f);
    fseek(f,pos,SEEK_SET);
    return len;
}
void __stdcall Com_Error(const char *fmt, ... ) 
{
    char    com_errorMessage[4096];
    va_list        argptr; 
 
    va_start (argptr,fmt);
    vsprintf (com_errorMessage,fmt,argptr);
    va_end (argptr); 
 
    MessageBox(NULL,com_errorMessage,"错误提示",MB_ICONERROR);
} 
 
bool LoadBMP( const char *name, byte **pic, int *width, int *height )
{
    int        columns, rows, numPixels;
    byte    *pixbuf;
    int        row, column;
    byte    *buf_p;
    byte    *buffer;
    int        length;
    BMPHeader_t bmpHeader;
    byte        *bmpRGBA;
    *pic = NULL;
    // load the file
    FILE* pfile = fopen(name,"rb");
    if(pfile == NULL)
    {
        Com_Error( "LoadBMP: Load BMP files failed (%s)\n", name );
        return false;
    }
    length = GetFileSize(pfile);
    buffer = (byte*) malloc(length*sizeof(byte));
    fread(buffer,1,length,pfile);
    if (!buffer) 
    {
        Com_Error( "LoadBMP: Memory alloc failed (%s)\n", name );
        return false;
    } 
 
    buf_p = buffer; 
 
    bmpHeader.id[0] = *buf_p++;
    bmpHeader.id[1] = *buf_p++;
    bmpHeader.fileSize = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.reserved0 = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.bitmapDataOffset = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.bitmapHeaderSize = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.width = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.height = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.planes = ( * ( short * ) buf_p );
    buf_p += 2;
    bmpHeader.bitsPerPixel = ( * ( short * ) buf_p );
    buf_p += 2;
    bmpHeader.compression = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.bitmapDataSize = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.hRes = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.vRes = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.colors = ( * ( long * ) buf_p );
    buf_p += 4;
    bmpHeader.importantColors = ( * ( long * ) buf_p );
    buf_p += 4; 
 
    memcpy( bmpHeader.palette, buf_p, sizeof( bmpHeader.palette ) ); 
 
    if ( bmpHeader.bitsPerPixel == 8 )
        buf_p += 1024; 
 
    if ( bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M' ) 
    {
        Com_Error( "LoadBMP: only Windows-style BMP files supported (%s)\n", name );
        return false;
    }
    if ( bmpHeader.fileSize != length )
    {
        //Com_Error("LoadBMP: header size does not match file size (%d vs. %d) (%s)\n", bmpHeader.fileSize, length, name );
        //return false;
    }
    if ( bmpHeader.compression != 0 )
    {
        Com_Error("LoadBMP: only uncompressed BMP files supported (%s)\n", name );
        return false;
    }
    if ( bmpHeader.bitsPerPixel < 8 )
    {
        Com_Error("LoadBMP: monochrome and 4-bit BMP files not supported (%s)\n", name );
        return false;
    } 
 
    columns = bmpHeader.width;
    rows = bmpHeader.height; 
 
    if(bmpHeader.bitsPerPixel == 24 )
    {
        if( (columns & 3) != 0)                    //检查宽度是否为4倍数
           columns = (columns & ~3) + 4;    //修正位图宽度值,对齐到4的倍数,不然图像会变形   
    } 
 
    if ( rows < 0 )
        rows = -rows;
    numPixels = columns * rows; 
 
    if ( width ) 
        *width = columns;
    if ( height )
        *height = rows; 
 
    bmpRGBA = (byte*)malloc( numPixels * 4 );
    *pic = bmpRGBA;
    buf_p = buffer+54; 
 
    for ( row = rows-1; row >= 0; row--)
    {
        pixbuf = bmpRGBA + row*columns*4; 
 
        for ( column = 0; column < columns; column++ )
        {
            unsigned char red, green, blue, alpha;
            int palIndex;
            unsigned short shortPixel; 
 
            switch ( bmpHeader.bitsPerPixel )
            {
            case 8:
                palIndex = *buf_p++;
                *pixbuf++ = bmpHeader.palette[palIndex][2];
                *pixbuf++ = bmpHeader.palette[palIndex][1];
                *pixbuf++ = bmpHeader.palette[palIndex][0];
                *pixbuf++ = 0xff;
                break;
            case 16:
                shortPixel = * ( unsigned short * ) pixbuf;
                pixbuf += 2;
                *pixbuf++ = ( shortPixel & ( 31 << 10 ) ) >> 7;
                *pixbuf++ = ( shortPixel & ( 31 << 5 ) ) >> 2;
                *pixbuf++ = ( shortPixel & ( 31 ) ) << 3;
                *pixbuf++ = 0xff;
                break; 
 
            case 24:
                blue = *buf_p++;
                green = *buf_p++;
                red = *buf_p++;
                *pixbuf++ = red;
                *pixbuf++ = green;
                *pixbuf++ = blue;
                *pixbuf++ = 255;
                break;
            case 32:
                blue = *buf_p++;
                green = *buf_p++;
                red = *buf_p++;
                alpha = *buf_p++;
                *pixbuf++ = red;
                *pixbuf++ = green;
                *pixbuf++ = blue;
                *pixbuf++ = alpha;
                break;
            default:
                Com_Error("LoadBMP: illegal pixel_size '%d' in file '%s'\n", bmpHeader.bitsPerPixel, name );
                return false;
            }
        }
    } 
 
    free(buffer);
    fclose(pfile);
    return true;
}
 
int main()
{	
 
for(int i=1;i<10000;i++)
{
	char name[30];
	static byte* pic = NULL;
	static byte* p;
	static int w,h;
	wsprintf(name,"%d.bmp",i);
	LoadBMP(name,&pic,&w,&h);
	wsprintf(name,"%d.txt",i);
	freopen(name,"w",stdout);
	int i,j;
	//第1个 
	p=pic;
	for(j=0;j<10;j++)
	{
        for(i=0;i<10;i++)
    	{            
        	printf("%06X",RGB(p[0],p[1],p[2]));
        	p += 4;
    	}
    	p+=120;
	}
	printf("\n");
	//第2个 
	p=pic+40;
	for(j=0;j<10;j++)
	{
        for(i=0;i<10;i++)
    	{            
        	printf("%06X",RGB(p[0],p[1],p[2]));
        	p += 4;
    	}
    	p+=120;
	}
	printf("\n");
	//第3个 
	p=pic+80;
	for(j=0;j<10;j++)
	{
        for(i=0;i<10;i++)
    	{            
        	printf("%06X",RGB(p[0],p[1],p[2]));
        	p += 4;
    	}
    	p+=120;
	}
	printf("\n");
	//第4个 
	p=pic+120;
	for(j=0;j<10;j++)
	{
        for(i=0;i<10;i++)
    	{            
        	printf("%06X",RGB(p[0],p[1],p[2]));
        	p += 4;
    	}
    	p+=120;
	}
	printf("\n");
}
	return 0;
}

#include <stdio.h>
#include <windows.h>
int main()
{	
	char result[10][1024];
	//读入答案
	FILE *fp;
	fp=fopen("答案.txt","rb");
	for(int i=0;i<10;i++)
	{
		fgets(result[i],1024,fp);
		//printf(result[i]);
	}
	fclose(fp);
	//读取文件
	for(int i=1;i<10000;i++)
	{
		char name[30];
		char temp[1024];
		wsprintf(name,"%d.txt",i);
		fp=fopen(name,"rb");
		//printf("%d:",i);
		for(int j=0;j<4;j++)
		{
            fgets(temp,1024,fp);
			for(int k=0;k<10;k++)
			{
                if(strcmp(result[k],temp)==0)
				{
					printf("%d",k);
					break;
				}
			}
 
		}
		printf("\n");
		fclose(fp);
 
	}
	getchar();
	return 0;
}

import java.io.*;
import java.math.BigDecimal;
 
public class 大数2 {
	public static void main(String[] arg) throws IOException {
		BigDecimal sum=new BigDecimal(0);
		long x=0;
		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader buf = new BufferedReader(isr);
		for (int i = 1; i < 10000; i++) {
			x= i*Integer.valueOf(buf.readLine()) ;
			sum=sum.add(new BigDecimal(x));
		}
		System.out.println(sum);
	}
}

#include <stdio.h>
#include <windows.h>
long GetFileSize(FILE* fp)   
{   
	long len;
	long now = ftell(fp);
	fseek(fp, 0, SEEK_END);   
    len   =   ftell(fp);   
    fseek(fp, now, SEEK_SET);   
    return len;   
}
int main(int argc,char *argv[])
{
	if(argc!=3)
	{
		puts("参数不正确！");
		return 0;
	}
    FILE *fp = fopen(argv[1],"rb");
 
 
	char announce[1024];
	char newwebsite[1024];
	char head[1024];
 
	int num;
	fscanf(fp,"d8:announce%d:",&num);
	fread(announce,num,1,fp);
	if(strstr(announce,"free.stonept.org"))
	{
		printf("%s 未转换\n",argv[1]);
		//return 0;
	}
	else{
        strcpy(newwebsite,"http://free.stonept.org/announce.php");
        printf("%s 已转换\n",argv[1]);
    }
    FILE *out = fopen(argv[2],"wb");
    wsprintf(head,"d8:announce%d:%s",strlen(newwebsite),newwebsite);
    fputs(head,out);
    long fl = GetFileSize(fp);
    while(ftell(fp)<fl){
          fputc(fgetc(fp),out);
    }
	fclose(fp);
	fclose(out);
}

@echo off
COLOR 0A
cls
title Tracker announce 自动转换程序
echo 此脚本由shuax制作
echo.
echo.
echo 请选择要执行的操作：
echo 1、转换为自由区Tracker
echo 2、转换为高清区Tracker
echo.
set /p choice=请选择：
 
if /i "%choice%"=="1" goto free
if /i "%choice%"=="2" goto hd
:free
for %%i in (*.torrent) do (
	自由区 "%%i" [free]"%%i" 
)
echo+
PAUSE
exit
 
:hd
for %%i in (*.torrent) do (
	高清区 "%%i" [hd]"%%i" 
)
echo+
PAUSE
exit

import java.awt.*;
import java.awt.event.*;
 
import javax.swing.*;
 
public class 启动 extends JFrame implements ActionListener{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	JTextField 用户;
	JPasswordField 密码;
	JButton 登录,注册,找回;
	public static void main(String args[]){
		try {
		    UIManager.setLookAndFeel("com.seaglasslookandfeel.SeaGlassLookAndFeel");
		    UIManager.put("PasswordField.font",new Font("Verdana",Font.BOLD,12));
		    //UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
		    /*
		    Font f = new Font("微软雅黑",Font.PLAIN,12);
			UIManager.put("TextField.font", f); 
			UIManager.put("Label.font", f);
			UIManager.put("ComboBox.font",f);
			UIManager.put("MenuBar.font",f);
			UIManager.put("ToolTip.font",f);
			UIManager.put("MenuItem.font",f);
			UIManager.put("Button.font",f);
			*/
		}catch (Exception e) {
			try {
				UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
			}catch (Exception e2) {}
			JOptionPane.showMessageDialog(null, "加载皮肤失败，使用默认界面。","警告", JOptionPane.YES_NO_CANCEL_OPTION);
		}
		new 启动();
	}
	public 启动(){
 
		super("QQ2010");
		UIManager.put("PasswordField.echoChar",'●');
		setLayout(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setResizable(false);
		JLabel user,pass;
		JLabel banner = new JLabel(new ImageIcon(getClass().getResource("/banner.png")));
		banner.setBounds(0, 0, 324, 47);
		add(banner);
		user = new JLabel("账　　号：");
		pass = new JLabel("密　　码：");
		user.setBounds(15,  60, 140, 30);
		pass.setBounds(15, 110, 140, 30);
		用户 = new JTextField();
		密码 = new JPasswordField();
		密码.setEchoChar('●');
		用户.setBounds(90,  60, 220, 30);
		密码.setBounds(90, 110, 220, 30);
 
		add(user);
		add(pass);
		add(用户);
		add(密码);
		登录 = new JButton("登录");
		注册 = new JButton("注册");
		找回 = new JButton("找回密码");
		登录.setBounds(210, 155, 100, 30);
		注册.setBounds(110, 155, 100, 30);
		找回.setBounds(10, 155, 100, 30);
		add(注册);
		add(登录);
		add(找回);
		登录.addActionListener(this);
		注册.addActionListener(this);
		找回.addActionListener(this);
		setSize(324,220);
		setLocationRelativeTo(null);
		setVisible(true);
	}
	public void actionPerformed(ActionEvent e){
		if(e.getSource()==注册){
			setVisible(false);
			new 注册();
		}else if(e.getSource()==找回){
			setVisible(false);
			new 找回密码();
		}else if(e.getSource()==登录){
			setVisible(false);
			new 主界面();
		}
	}
}

import java.awt.event.*;
import javax.swing.*;
 
public class 注册 extends JFrame implements ActionListener{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	JTextField 账号,昵称,邮箱;
	JPasswordField 密码1,密码2;
	JButton 注册,返回;
 
	public 注册(){
		super("QQ2010");
		setLayout(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setResizable(false);
 
		int 宽度  = 220;
		int 高度 = 30;
 
		String label1[]={"注册提示：请仔细填写每项数据！","账　　号：","昵　　称：","邮　　箱：","密　　码：","重复密码："};
		JLabel 标签[] = new JLabel[label1.length];
		for(int i=0;i<label1.length;i++){
			标签[i] = new JLabel(label1[i]);
			标签[i].setBounds(10, 5+i*30, 宽度, 高度);
			add(标签[i]);
		}
		String label2[]={"账号必须唯一","可任意填写","找回密码的凭据","请保证密码强度","确认密码"};
		JLabel 提示[] = new JLabel[label2.length];
		for(int i=0;i<label2.length;i++){
			提示[i] = new JLabel(label2[i]);
			提示[i].setBounds(315, 35+i*30, 宽度, 高度);
			add(提示[i]);
		}
 
		账号  = new JTextField();
		昵称  = new JTextField();
		邮箱  = new JTextField();
		账号.setBounds(90, 35, 宽度, 高度);
		昵称.setBounds(90, 65, 宽度, 高度);
		邮箱.setBounds(90, 95, 宽度, 高度);
 
		密码1 = new JPasswordField();
		密码2 = new JPasswordField();
		密码1.setEchoChar('●');
		密码2.setEchoChar('●');
		密码1.setBounds(90, 125, 宽度, 高度);
		密码2.setBounds(90, 155, 宽度, 高度);
 
		add(账号);
		add(昵称);
		add(邮箱);
		add(密码1);
		add(密码2);
		注册 = new JButton("注册");
		返回 = new JButton("返回");
		注册.setBounds( 90, 192, 100, 30);
		返回.setBounds(210, 192, 100, 30);
		add(注册);
		add(返回);
		注册.addActionListener(this);
		返回.addActionListener(this);
		setSize(420,255);
		setVisible(true);
		setLocationRelativeTo( null );
	}
	public void actionPerformed(ActionEvent e){
		if(e.getSource()==返回){
			setVisible(false);
			new 启动();
		}else if(e.getSource()==注册){
 
		}
	}
}

import java.awt.*;
import java.awt.event.*;
 
import javax.swing.*;
import javax.swing.tree.*;
public class 主界面 extends JFrame implements ActionListener {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
    private Rectangle rect;
    private Point point;
    private Timer timer = new Timer(10, this);;
 
    JPanel main,login;
    JProgressBar 进度条;
    JFrame fr;
    JButton 关于,添加;
	public 主界面(){
		super("QQ2010");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setResizable(false);
		setSize(250,630);
		fr = this;
 
		//登录界面
		login = new JPanel();
		login.setLayout(null);
		GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
		GraphicsDevice graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();
		DisplayMode displayMode = graphicsDevice.getDisplayMode();
		setLocation(displayMode.getWidth()-50-250,50);
		//JLabel 图片 = new JLabel(new ImageIcon("logo.png"));
		JLabel 图片 = new JLabel(new ImageIcon(getClass().getResource("/logo.png")));
		JLabel 登录 = new JLabel("正在登录...");
		进度条 = new JProgressBar(JProgressBar.HORIZONTAL);
		进度条.setValue(20);
		图片.setBounds(68, 165, 100, 100);
		登录.setBounds(90, 230, 100, 100);
		进度条.setBounds(40, 290, 160, 20);
		login.add(图片,BorderLayout.NORTH);
		login.add(登录,BorderLayout.CENTER);
		login.add(进度条,BorderLayout.SOUTH);
		add(login);
 
 
		//主界面
		main = new JPanel();
		main.setLayout(null);
		JPanel 个人面板 = new JPanel();
		个人面板.setLayout(new BorderLayout(5,5));
		JLabel 头像 = new JLabel(new ImageIcon(getClass().getResource("/qq.png")));
		JLabel 名字 = new JLabel("<html>QQ:369339353 [在线]<br>耍下 www.shuax.com<br>版本:0.0.1 beta</html>");
		个人面板.add(头像,BorderLayout.WEST);
		个人面板.add(名字,BorderLayout.CENTER);
		个人面板.setBounds(0, 0, 250, 60);
		main.add(个人面板);
		DefaultMutableTreeNode root= new DefaultMutableTreeNode();
		DefaultMutableTreeNode parent;
 
		parent = new DefaultMutableTreeNode("我的好友");
		root.add(parent);
		for(int i=0;i<50;i++){
			parent.add(new DefaultMutableTreeNode("Cn_Harmony. "+i));
		}
 
		parent.add(new DefaultMutableTreeNode("..."));
		parent.add(new DefaultMutableTreeNode("止殇♂"));
		parent.add(new DefaultMutableTreeNode("街头，想着伱"));
		parent.add(new DefaultMutableTreeNode("埃及艳后"));
 
 
		parent = new DefaultMutableTreeNode("陌生人");
		root.add(parent);
		parent.add(new DefaultMutableTreeNode("那片天"));
		parent.add(new DefaultMutableTreeNode("^Q^"));
 
		JTree 好友= new JTree(root);
		好友.addMouseListener(
			new MouseAdapter(){
				public void mousePressed(MouseEvent e)
				{
					try {
						if(e.getClickCount()==2){
							DefaultMutableTreeNode node = (DefaultMutableTreeNode) ((JTree) e.getSource()).getPathForLocation(e.getX(), e.getY()).getLastPathComponent();
							Object userInfo = node.getUserObject();	
							 if (node.isLeaf()) {
							      JOptionPane.showMessageDialog(null, "你选择了好友："+userInfo.toString());
							    //new 聊天窗口();
							 }
						}
					}catch(Exception e1){}
				}
			}
		);
		好友.setRootVisible(false);
		JScrollPane 滚动 = new JScrollPane(好友);
		滚动.setBounds(0, 60, 250, 500);
		main.add(滚动);
 
		JPanel info = new JPanel();
		info.setLayout(null);
		关于  = new JButton("关于");
		添加  = new JButton("添加好友");
		关于.setBounds(15, 0, 100, 30);
		添加.setBounds(135, 0, 100, 30);
		info.add(关于);
		info.add(添加);
		关于.addActionListener(this);
		添加.addActionListener(this);
		info.setBounds(0, 565, 250, 60);
		main.add(info);
		滚动().start();
        timer.start();
        setVisible(true);
	}
	public Thread 滚动()
    {
        return new Thread()
        {
			public void run(){
				int i = 进度条.getValue();
				int j = 0;
				while(j<90)
				{
					进度条.setValue(i++);
					if(i>=100) i=0;
					try {
						Thread.sleep(5);
					} catch (Exception e) {}
					j++;
				}
				login.setVisible(false);
				fr.add(main);
			}
        };
    }
    public boolean isPtInRect(Rectangle rect, Point point) {
        if (rect != null && point != null) {
            int x0 = rect.x;
            int y0 = rect.y;
            int x1 = rect.width;
            int y1 = rect.height;
            int x = point.x;
            int y = point.y;
 
            return x >= x0 && x < x1 && y >= y0 && y < y1;
        }
        return false;
    }
	public void actionPerformed(ActionEvent e){
		rect = new Rectangle(0, 0, getWidth(), getHeight());
        point = getMousePosition();
        if ((getLocationOnScreen().y < 0) && isPtInRect(rect, point)) {
            setLocation(getLocationOnScreen().x, 0);
        } else if (getLocationOnScreen().y > -2 && getLocationOnScreen().y < 2 && !(isPtInRect(rect, point))) {
            setLocation(getLocationOnScreen().x, 2 - getHeight());
        }
        if(e.getSource()==关于){
        	 JOptionPane.showMessageDialog(null, "程序开发：舒俊杰\n二〇一〇年四月二十一日","关于",JOptionPane.INFORMATION_MESSAGE);
		}else if(e.getSource()==添加){
		}
	}
}