// LANShare.cpp : 定义 DLL 的初始化例程。
//

#include "stdafx.h"
#include "LANShare.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////////
#include <shlwapi.h>

#include <Winnetwk.h>
#pragma comment(lib, "Mpr.lib.")

#include <Lm.h>
#include <Lmshare.h>
#pragma comment(lib, "Netapi32.lib")

#include <Aclapi.h>
#pragma comment(lib, "Advapi32.lib")
//////////////////////////////////////////////////////////////////////////
//使用Windows的HeapAlloc函数进行动态内存分配
#define myheapalloc(x) (HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, x))
#define myheapfree(x)  (HeapFree(GetProcessHeap(), 0, x))

typedef BOOL (WINAPI *SetSecurityDescriptorControlFnPtr)(
	IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
	IN SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,
	IN SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet);

typedef BOOL (WINAPI *AddAccessAllowedAceExFnPtr)(
	IN PACL pAcl,
	IN DWORD dwAceRevision,
	IN DWORD AceFlags,
	IN DWORD AccessMask,
	IN PSID pSid
	);

//
//TODO: 如果此 DLL 相对于 MFC DLL 是动态链接的，
//		则从此 DLL 导出的任何调入
//		MFC 的函数必须将 AFX_MANAGE_STATE 宏添加到
//		该函数的最前面。
//
//		例如:
//
//		extern "C" BOOL PASCAL EXPORT ExportedFunction()
//		{
//			AFX_MANAGE_STATE(AfxGetStaticModuleState());
//			// 此处为普通函数体
//		}
//
//		此宏先于任何 MFC 调用
//		出现在每个函数中十分重要。这意味着
//		它必须作为函数中的第一个语句
//		出现，甚至先于所有对象变量声明，
//		这是因为它们的构造函数可能生成 MFC
//		DLL 调用。
//
//		有关其他详细信息，
//		请参阅 MFC 技术说明 33 和 58。
//

// CLANShareApp

BEGIN_MESSAGE_MAP(CLANShareApp, CWinApp)
END_MESSAGE_MAP()


// CLANShareApp 构造

CLANShareApp::CLANShareApp()
{
	// TODO: 在此处添加构造代码，
	// 将所有重要的初始化放置在 InitInstance 中
}


// 唯一的一个 CLANShareApp 对象

CLANShareApp theApp;


// CLANShareApp 初始化

BOOL CLANShareApp::InitInstance()
{
	CWinApp::InitInstance();

	return TRUE;
}


//////////////////////////////////////////////////////////////////////////
/************************************************************************/
/*  函数：MultiToWide[5/14/2016 home];
/*  描述：将多字节字符串转成宽字节字符串;
/*  参数：;
/*  	[IN] pszMultiString：多字节字符串;
/*  返回：若转换成功,返回宽字节字符串, 否则返回NULL;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
WCHAR* MultiToWide(IN const CHAR* pszMultiString)
{
	int wSize = MultiByteToWideChar(CP_ACP, 0, pszMultiString, -1, NULL, 0);
	if (wSize == ERROR_NO_UNICODE_TRANSLATION || wSize == 0 )
	{
		return NULL;
	}

	WCHAR *punicode = new WCHAR[wSize];
	int convresult = MultiByteToWideChar(CP_ACP, 0, pszMultiString, -1, punicode, wSize);
	if (convresult != wSize)
	{
		if (punicode) delete []punicode;
		return NULL;
	}

	return punicode;
}

INT WideToMulti(IN const WCHAR* pWideString, IN LPCH pMultiString, IN const int& nBufLen)
{
	INT nSize = WideCharToMultiByte(CP_OEMCP, 0, pWideString, -1, NULL, 0, NULL, NULL); 
	if (nSize == ERROR_NO_UNICODE_TRANSLATION || nSize == 0 ) 
	{ 
		return 0;
	} 

	if ( nSize > nBufLen )
		return 0;

	INT nResult = WideCharToMultiByte(CP_OEMCP, 0, pWideString, -1, pMultiString, nSize, NULL, NULL); 
	if (nResult != nSize) 
	{ 
		return 0;
	} 

	return nSize; 
}

/************************************************************************/
/*  函数：DisConnectSession[5/14/2016 home];
/*  描述：断开指定的局域网共享连接;
/*  参数：;
/*  	[IN] lpHostAddr：要断开连接的局域网地址;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
extern "C" BOOL PASCAL EXPORT DisConnectSession( IN LPCTSTR lpHostAddr )
{
	if (NULL == lpHostAddr || lpHostAddr[0] == _T('\0'))
		return FALSE;

	DWORD dwRes = WNetCancelConnection2(lpHostAddr, CONNECT_UPDATE_PROFILE, TRUE);
	if ( ERROR_SUCCESS == dwRes || ERROR_NOT_CONNECTED == dwRes)
		_tprintf_s(_T("关掉局域网共享成功[%s]\n"), lpHostAddr);
	else 
		_tprintf_s(_T("关掉局域网共享失败[%s]Error:%d\n"), lpHostAddr, dwRes);

	return ( ERROR_SUCCESS == dwRes || ERROR_NOT_CONNECTED == dwRes ) ? TRUE : FALSE;
}

/************************************************************************/
/*  函数：[5/14/2016 home];
/*  描述：取消共享,但并不是删除这个目录;
/*  参数：;
/*  	[IN] lpShareName：要取消的共享名;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
extern "C" BOOL PASCAL EXPORT DelShareDirectoryW(IN LPCWSTR lpShareName)
{
	if (NULL == lpShareName || lpShareName[0] == _T('\0'))
		return FALSE;

	DWORD dwRes = NetShareDel(NULL, const_cast<LPWSTR>(lpShareName), NULL);
	if ( dwRes == NERR_Success )
		_tprintf_s(_T("删除共享成功"));
	else
		_tprintf_s(_T("删除共享失败,Error %d\n"), dwRes);
	
	return (dwRes == NERR_Success) ? TRUE : FALSE;
}

extern "C" BOOL PASCAL EXPORT DelShareDirectoryA(IN LPCCH lpShareName)
{
	if ( lpShareName == NULL )
		return TRUE;

	WCHAR* pShareName = MultiToWide(lpShareName);
	BOOL bRes = DelShareDirectoryW(pShareName);

	if ( pShareName )
		delete []pShareName;

	return bRes;
}

/************************************************************************/
/*  函数：IsTheDirectoryShared[5/12/2016 IT];
/*  描述：判断本地目录是否共享,若共享则返回共享名称;
/*  参数：;
/*  	[IN] lpDirectory：本地路径;
/*  	[OUT] lpShareName：若本地路径已共享,返回共享名称;
/*  	[IN] nBufLen：lpShareName缓冲区大小;
/*  返回：若已共享返回TRUE;
/*  注意：该函数字符编号是UICODE;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
extern "C" BOOL PASCAL EXPORT IsTheDirectorySharedW(IN LPCWSTR lpDirectory, OUT LPWSTR lpShareName  = NULL , IN const INT& nBufLen  = 0 )
{
	if ( lpDirectory == NULL || !PathFileExistsW(lpDirectory) ){
		_tprintf_s(_T("要判断的路径无效"));
		return FALSE;
	}

	if ( lpDirectory[0] == L'\\' && lpDirectory[1] == L'\\' ){
		_tprintf_s(_T("要判断的路径是网络路径"));
		return TRUE;
	}

	// 枚举本机所有共享目录;
	PSHARE_INFO_502 BufPtr, p;
	NET_API_STATUS res;
	LPTSTR lpszServer = NULL;
	DWORD er = 0, tr = 0, resume = 0, i;

	do
	{
		res = NetShareEnum(NULL, 502, (LPBYTE*)&BufPtr, MAX_PREFERRED_LENGTH, &er, &tr, &resume);
		if ( res == ERROR_SUCCESS || res == ERROR_MORE_DATA )
		{
			p = BufPtr;
			for ( i = 1; i <= er; i++ )
			{
				if ( p->shi502_type == STYPE_DISKTREE )
				{// 磁盘类型;
					printf("%-20S%-30S\n", p->shi502_netname, p->shi502_path);
					if ( wcscmp(lpDirectory, (WCHAR*)(p->shi502_path)) == 0 )
					{
						if ( lpShareName && nBufLen > 0 )
							wcscpy_s(lpShareName, nBufLen, (WCHAR*)(p->shi502_netname));
						NetApiBufferFree(BufPtr);
						return TRUE;
					}
				}

				p++;
			}
			NetApiBufferFree(BufPtr);
		}
	} while (res == ERROR_MORE_DATA );

	return FALSE;
}

extern "C" BOOL PASCAL EXPORT IsTheDirectorySharedA(IN LPCCH lpDirectory, OUT LPCH lpShareName  = NULL , IN const INT& nBufLen  = 0  )
{
	if ( lpDirectory == NULL )
		return FALSE;

	WCHAR *pShareName = NULL;
	WCHAR *pDirectory = MultiToWide(lpDirectory);
	if ( lpShareName )
	{
		pShareName = new WCHAR[nBufLen + 1];
		memset(pShareName, 0, sizeof(WCHAR)*(nBufLen+1));
	}

	BOOL bRes = IsTheDirectorySharedW(pDirectory, pShareName, nBufLen);
	if ( bRes )
		WideToMulti(pShareName, lpShareName, nBufLen);
	
	if ( pDirectory )
		delete []pDirectory;
	if ( pShareName )
		delete []pShareName;

	return bRes;
}

/************************************************************************/
/*  函数：AccessShareDirectory[5/11/2016 IT];
/*  描述：访问指定账号和密码的局域网共享目录;
/*  参数：;
/*  	[IN] lpUserName：登陆共享目录的账号;
/*  	[IN] lpPasswd：登陆共享目录的密码;
/*  	[IN] lpShareDirectory：要登陆的共享目录（"\\it-pc\Test\123"）;
/*  返回：成功返回true;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
extern "C" BOOL PASCAL EXPORT AccessShareDirectory(IN LPCTSTR lpUserName, IN LPCTSTR lpPasswd, IN LPCTSTR lpShareDirectory)
{
	// 参数有效性判断;
	if (lpShareDirectory == NULL || 
		lpShareDirectory[0] == _T('\0') ||
		lpShareDirectory[0] != _T('\\'))
	{
		return FALSE;
	}

	int nPos = 0;
	DWORD dwError = 0;
	CString strHostAddr = lpShareDirectory;
	// 从lpShareDirectory解析出网络主机地址,且主机名末尾不能包含'\\';
	if ( strHostAddr.Left(2) != _T("\\\\") )
		return FALSE;

	nPos = strHostAddr.Mid(2).Find(_T("\\"));
	if ( nPos != -1 )
	{
		strHostAddr = strHostAddr.Left(nPos+2);
	}

	// 断开之前的连接;
	dwError = WNetCancelConnection2(strHostAddr, CONNECT_UPDATE_PROFILE, TRUE);
	if ( dwError != ERROR_SUCCESS && dwError != ERROR_NOT_CONNECTED)
	{
		_tprintf_s(_T("断开失败\n"));
	}

	NETRESOURCE net_Resource;
	net_Resource.dwDisplayType = RESOURCEDISPLAYTYPE_DIRECTORY;
	net_Resource.dwScope = RESOURCE_CONNECTED;
	net_Resource.dwType = RESOURCETYPE_ANY;
	net_Resource.dwUsage = 0;
	net_Resource.lpComment = TEXT("");
	net_Resource.lpLocalName = NULL;			// 不映射成本地驱动器;
	net_Resource.lpProvider= NULL;
	net_Resource.lpRemoteName = const_cast<LPTSTR>(strHostAddr.GetString());
	DWORD dwFlags = CONNECT_UPDATE_PROFILE;
	dwError = WNetAddConnection2(&net_Resource, lpPasswd, lpUserName, dwFlags);
	switch(dwError)
	{
	case ERROR_SUCCESS:
		_tprintf(TEXT("访问共享成功！"));
		break;
	case ERROR_ACCESS_DENIED:
		_tprintf(TEXT("没有权访问！"));
		break;
	case ERROR_ALREADY_ASSIGNED:
		ShellExecute(NULL, TEXT("open"), TEXT("z:"), NULL, NULL, SW_SHOWNORMAL);
		break;
	case ERROR_INVALID_ADDRESS:
		_tprintf(TEXT("IP地址无效"));
		break;
	case ERROR_NO_NETWORK:
		_tprintf(TEXT("网络不可达!"));
		break;
	}

	return dwError;
}

/************************************************************************/
/*  函数：[5/11/2016 Home];
/*  描述：;
/*  参数：;
/*  	[IN] lpDirectory：要共享的本地目录;
/*  	[IN] lpShareName：要共享的本地目录的共享名称;
/*  返回：成功返回0;
/*  注意：该函数字符编号是UICODE;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
extern "C" BOOL PASCAL EXPORT AddShareDirectoryW(IN LPCWSTR lpDirectory, IN LPCWSTR lpShareName)
{
	if ( lpDirectory == NULL || !PathFileExistsW(lpDirectory) ){
		_tprintf_s(_T("设置共享的目录无效\n"));
		return FALSE;
	}

	if ( lpShareName == NULL || lpShareName[0] == _T('\0') ){
		_tprintf_s(_T("设置共享的名称无效\n"));
		return FALSE;
	}

	DWORD dwEr = 0;
	DWORD dwRet = 0;
	SHARE_INFO_2 si2;
	memset(&si2, 0, sizeof(SHARE_INFO_2));

	si2.shi2_netname = const_cast<LPWSTR>(lpShareName);			// 要设置目录的共享名称(必须为Unicode);
	si2.shi2_type = STYPE_DISKTREE;			// 要共享的类型STYPE_DISKTREE=磁盘驱动器;
	si2.shi2_remark = NULL;					// 共享资源的可选注释;
	si2.shi2_permissions = ACCESS_ALL;		// 共享资源的共享权限（对xp来说,这个值设置成什么都是无效的）;
	si2.shi2_max_uses = -1;					// 共享资源最大可访问用户量;
	si2.shi2_current_uses = 0;				// 当前可访问量;
	si2.shi2_passwd = NULL;					// 共享密码 NULL表示没密码;
	si2.shi2_path = const_cast<LPWSTR>(lpDirectory);			// 要共享的目录;

	dwRet = NetShareAdd(NULL, 2, (LPBYTE)&si2, &dwEr);
	if ( dwRet == NERR_Success || dwRet == NERR_DuplicateShare )
	{
		_tprintf_s(_T("设置共享成功\n"));
		// 刷新文件列表;
		SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
	}
	else
	{
		_tprintf_s(_T("设置共享失败 Error %u\n"), dwRet);
	}

	return ( dwRet == NERR_Success || dwRet == NERR_DuplicateShare ) ? TRUE : FALSE;
	//return SetNetShareSecurity(lpShareName, _T("Everyone"));
}

extern "C" BOOL PASCAL EXPORT AddShareDirectoryA(IN LPCCH lpDirectory, IN LPCCH lpShareName)
{
	WCHAR *pShareName = NULL;
	WCHAR *pDirectory = NULL;
	if ( lpDirectory )
		pDirectory = MultiToWide(lpDirectory);

	if ( lpShareName )
		pShareName = MultiToWide(lpShareName);

	BOOL bRes = AddShareDirectoryW(pDirectory, pShareName);
	if ( pDirectory )
		delete []pDirectory;
	if ( pShareName )
		delete []pShareName;

	return bRes;
}

/************************************************************************/
/*  函数：SetNetShareSecurity[5/12/2016 IT];
/*  描述：设置共享目录的安全选项;
/*  参数：;
/*  	[IN] lpShareName：要设置的共享名称;
/*  	[OUT] lpUsser：安全选项用户;
/*  	[IN/OUT] ：;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
extern "C" BOOL PASCAL EXPORT SetNetShareSecurity(IN LPCTSTR lpShareName, IN LPCTSTR lpUsser, IN const DWORD& dwPermissions  = STANDARD_RIGHTS_ALL| SPECIFIC_RIGHTS_ALL )
{
	if ( lpShareName == NULL || lpUsser == NULL ){
		_tprintf_s(_T("共享名称或用户名无效\n"));
		return FALSE;
	}

	// 设置成功后,给共享目录分配权限;
	DWORD dwRes = 0;
	PACL pOldDacl = NULL;
	PACL pNewDacl = NULL;
	EXPLICIT_ACCESS ea;
	PSECURITY_DESCRIPTOR psd = NULL;

	// 获取指定对象名称的DACL(Discretionary Access Control List任意访问控制列表)指针对象;
	dwRes = GetNamedSecurityInfo(const_cast<LPTSTR>(lpShareName), SE_LMSHARE, DACL_SECURITY_INFORMATION, NULL, NULL, &pOldDacl, NULL, &psd);
	if (  ERROR_SUCCESS != dwRes ) {
		_tprintf_s(_T("GetNamedSecurityInfo Error %u\n"), dwRes); // dwRes = 2310表示没有这个共享名称;
		goto Cleanup;
	}

	// 为新的ACE初始化EXPLICIT_ACCESS结构体;
	ZeroMemory(&ea, sizeof(EXPLICIT_ACCESS));
	// 设置最重要的访问权限;STANDARD_RIGHTS_ALL全部标准权限;SPECIFIC_RIGHTS_ALL全部特殊权限;
	ea.grfAccessPermissions = dwPermissions;
	ea.grfAccessMode = SET_ACCESS;
	ea.grfInheritance = CONTAINER_INHERIT_ACE;
	ea.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
	ea.Trustee.ptstrName = const_cast<LPTSTR>(lpUsser);

	// 合并新的ACE到现有的DACL来创建新的ACL;
	dwRes = SetEntriesInAcl(1, &ea, pOldDacl, &pNewDacl);
	if (ERROR_SUCCESS != dwRes)  {
		_tprintf_s(_T("SetEntriesInAcl Error %u\n"), dwRes );
		goto Cleanup; 
	}  

	// 用新的ACL附加到DACL对象中;
	dwRes = SetNamedSecurityInfo(const_cast<LPTSTR>(lpShareName), SE_LMSHARE, DACL_SECURITY_INFORMATION, NULL, NULL, pNewDacl, NULL);
	if (ERROR_SUCCESS != dwRes)  {
		_tprintf_s( _T("SetNamedSecurityInfo Error %u\n"), dwRes );
		goto Cleanup; 
	} 

	// 设置成功后,刷新文件夹;
	SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
Cleanup:
	if ( psd != NULL )
		LocalFree((HLOCAL)psd);

	if ( pNewDacl != NULL )
		LocalFree((HLOCAL)pNewDacl);

	if ( pOldDacl != NULL )
		LocalFree((HLOCAL)pNewDacl);

	return (dwRes == ERROR_SUCCESS) ? TRUE : FALSE;
}


/************************************************************************/
/*  函数：[5/14/2016 home];
/*  描述：给指定的目录添加安全权限;
/*  参数：;
/*  	[IN] lpszFileName：文件或目录名;
/*  	[IN] lpszAccountName：要给文件或目录添加的安全账号;
/*  	[IN] dwAccessMask：要添加的权限值;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
extern "C" BOOL PASCAL EXPORT AddAccessRights(IN LPCTSTR lpszFileName, IN LPCTSTR lpszAccountName, IN const DWORD& dwAccessMask  = STANDARD_RIGHTS_ALL| SPECIFIC_RIGHTS_ALL )
{
	// 声明SID变量;
	SID_NAME_USE   snuType;

	// 声明和LookupAccountName相关的变量（注意，全为0，要在程序中动态分配）;
	TCHAR *        szDomain       = NULL;
	DWORD          cbDomain       = 0;
	LPVOID         pUserSID       = NULL;
	DWORD          cbUserSID      = 0;

	// 和文件相关的安全描述符 SD 的变量;
	PSECURITY_DESCRIPTOR pFileSD  = NULL;     // 结构变量;
	DWORD          cbFileSD       = 0;        // SD的size;

	// 一个新的SD的变量，用于构造新的ACL（把已有的ACL和需要新加的ACL整合起来）;
	SECURITY_DESCRIPTOR  newSD;

	// 和ACL 相关的变量;
	PACL           pACL           = NULL;
	BOOL           fDaclPresent = FALSE;
	BOOL           fDaclDefaulted = FALSE;
	ACL_SIZE_INFORMATION AclInfo;

	// 一个新的 ACL 变量;
	PACL           pNewACL        = NULL;  //结构指针变量;
	DWORD          cbNewACL       = 0;     //ACL的size;

	// 一个临时使用的 ACE 变量;
	LPVOID         pTempAce       = NULL;
	UINT           CurrentAceIndex = 0;  //ACE在ACL中的位置;

	UINT           newAceIndex = 0;  //新添的ACE在ACL中的位置;

	//API函数的返回值，假设所有的函数都返回失败。
	BOOL           fResult = FALSE;
	BOOL           fAPISuccess = FALSE;

	SECURITY_INFORMATION secInfo = DACL_SECURITY_INFORMATION;

	// 下面的两个函数是新的API函数，仅在Windows 2000以上版本的操作系统支持。 
	// 在此将从Advapi32.dll文件中动态载入。如果你使用VC++ 6.0编译程序，而且你想
	// 使用这两个函数的静态链接。则请为你的编译加上：/D_WIN32_WINNT=0x0500
	// 的编译参数。并且确保你的SDK的头文件和lib文件是最新的。
	SetSecurityDescriptorControlFnPtr _SetSecurityDescriptorControl = NULL;
	AddAccessAllowedAceExFnPtr _AddAccessAllowedAceEx = NULL;

	__try {
		// 
		// STEP 1: 通过用户名取得SID
		//     在这一步中LookupAccountName函数被调用了两次，第一次是取出所需要
		// 的内存的大小，然后，进行内存分配。第二次调用才是取得了用户的帐户信息。
		// LookupAccountName同样可以取得域用户或是用户组的信息。（请参看MSDN）
		//

		fAPISuccess = LookupAccountName(NULL, lpszAccountName,pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);

		// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
		// 下面是处理非内存不足的错误。

		if (fAPISuccess)
			__leave;
		else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
			_tprintf(TEXT("LookupAccountName() failed. Error %d/n"), GetLastError());
			__leave;
		}

		pUserSID = myheapalloc(cbUserSID);
		if (!pUserSID) {
			_tprintf(TEXT("HeapAlloc() failed. Error %d/n"), GetLastError());
			__leave;
		}

		szDomain = (TCHAR *) myheapalloc(cbDomain * sizeof(TCHAR));
		if (!szDomain) {
			_tprintf(TEXT("HeapAlloc() failed. Error %d/n"), GetLastError());
			__leave;
		}

		fAPISuccess = LookupAccountName(NULL, lpszAccountName,pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
		if (!fAPISuccess) {
			_tprintf(TEXT("LookupAccountName() failed. Error %d/n"), GetLastError());
			__leave;
		}

		// 
		// STEP 2: 取得文件（目录）相关的安全描述符SD
		//     使用GetFileSecurity函数取得一份文件SD的拷贝，同样，这个函数也
		// 是被调用两次，第一次同样是取SD的内存长度。注意，SD有两种格式：自相关的
		// （self-relative）和 完全的（absolute），GetFileSecurity只能取到“自
		// 相关的”，而SetFileSecurity则需要完全的。这就是为什么需要一个新的SD，
		// 而不是直接在GetFileSecurity返回的SD上进行修改。因为“自相关的”信息
		// 是不完整的。

		fAPISuccess = GetFileSecurity(lpszFileName, secInfo, pFileSD, 0, &cbFileSD);

		// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
		// 下面是处理非内存不足的错误。
		if (fAPISuccess)
			__leave;
		else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
			_tprintf(TEXT("GetFileSecurity() failed. Error %d/n"), GetLastError());
			__leave;
		}

		pFileSD = myheapalloc(cbFileSD);
		if (!pFileSD) {
			_tprintf(TEXT("HeapAlloc() failed. Error %d/n"), GetLastError());
			__leave;
		}

		fAPISuccess = GetFileSecurity(lpszFileName, secInfo, pFileSD, cbFileSD, &cbFileSD);
		if (!fAPISuccess) {
			_tprintf(TEXT("GetFileSecurity() failed. Error %d/n"), GetLastError());
			__leave;
		}

		// 
		// STEP 3: 初始化一个新的SD
		// 
		if (!InitializeSecurityDescriptor(&newSD, SECURITY_DESCRIPTOR_REVISION)) {
			_tprintf(TEXT("InitializeSecurityDescriptor() failed. Error %d/n"), GetLastError());
			__leave;
		}

		// 
		// STEP 4: 从GetFileSecurity 返回的SD中取DACL
		// 
		if (!GetSecurityDescriptorDacl(pFileSD, &fDaclPresent, &pACL, &fDaclDefaulted)) {
			_tprintf(TEXT("GetSecurityDescriptorDacl() failed. Error %d/n"), GetLastError());
			__leave;
		}

		// 
		// STEP 5: 取 DACL的内存size
		//     GetAclInformation可以提供DACL的内存大小。只传入一个类型为
		// ACL_SIZE_INFORMATION的structure的参数，需DACL的信息，是为了
		// 方便我们遍历其中的ACE。
		AclInfo.AceCount = 0; // Assume NULL DACL.
		AclInfo.AclBytesFree = 0;
		AclInfo.AclBytesInUse = sizeof(ACL);

		if (pACL == NULL)
			fDaclPresent = FALSE;

		// 如果DACL不为空，则取其信息。（大多数情况下“自关联”的DACL为空）
		if (fDaclPresent) {            
			if (!GetAclInformation(pACL, &AclInfo, sizeof(ACL_SIZE_INFORMATION), AclSizeInformation)) {
				_tprintf(TEXT("GetAclInformation() failed. Error %d/n"),GetLastError());
				__leave;
			}
		}

		// 
		// STEP 6: 计算新的ACL的size
		//    计算的公式是：原有的DACL的size加上需要添加的一个ACE的size，以
		// 及加上一个和ACE相关的SID的size，最后减去两个字节以获得精确的大小。
		cbNewACL = AclInfo.AclBytesInUse + sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(pUserSID) - sizeof(DWORD);


		// 
		// STEP 7: 为新的ACL分配内存
		// 
		pNewACL = (PACL) myheapalloc(cbNewACL);
		if (!pNewACL) {
			_tprintf(TEXT("HeapAlloc() failed. Error %d/n"), GetLastError());
			__leave;
		}

		// 
		// STEP 8: 初始化新的ACL结构
		// 
		if (!InitializeAcl(pNewACL, cbNewACL, ACL_REVISION2)) {
			_tprintf(TEXT("InitializeAcl() failed. Error %d/n"), GetLastError());
			__leave;
		}

		// 
		// STEP 9  如果文件（目录） DACL 有数据，拷贝其中的ACE到新的DACL中
		// 
		//     下面的代码假设首先检查指定文件（目录）是否存在的DACL，如果有的话，
		// 那么就拷贝所有的ACE到新的DACL结构中，我们可以看到其遍历的方法是采用
		// ACL_SIZE_INFORMATION结构中的AceCount成员来完成的。在这个循环中，
		// 会按照默认的ACE的顺序来进行拷贝（ACE在ACL中的顺序是很关键的），在拷
		// 贝过程中，先拷贝非继承的ACE（我们知道ACE会从上层目录中继承下来）
		//

		newAceIndex = 0;

		if (fDaclPresent && AclInfo.AceCount) {

			for (CurrentAceIndex = 0; CurrentAceIndex < AclInfo.AceCount;CurrentAceIndex++) {
				// 
				// STEP 10: 从DACL中取ACE
				// 
				if (!GetAce(pACL, CurrentAceIndex, &pTempAce)) {
					_tprintf(TEXT("GetAce() failed. Error %d/n"), GetLastError());
					__leave;
				}

				// 
				// STEP 11: 检查是否是非继承的ACE
				//     如果当前的ACE是一个从父目录继承来的ACE，那么就退出循环。
				// 因为，继承的ACE总是在非继承的ACE之后，而我们所要添加的ACE
				// 应该在已有的非继承的ACE之后，所有的继承的ACE之前。退出循环
				// 正是为了要添加一个新的ACE到新的DACL中，这后，我们再把继承的
				// ACE拷贝到新的DACL中。
				//
				if (((ACCESS_ALLOWED_ACE *)pTempAce)->Header.AceFlags & INHERITED_ACE)
					break;

				// 
				// STEP 12: 检查要拷贝的ACE的SID是否和需要加入的ACE的SID一样，
				// 如果一样，那么就应该废掉已存在的ACE，也就是说，同一个用户的存取
				// 权限的设置的ACE，在DACL中应该唯一。这在里，跳过对同一用户已设置
				// 了的ACE，仅是拷贝其它用户的ACE。
				// 
				if (EqualSid(pUserSID,&(((ACCESS_ALLOWED_ACE *)pTempAce)->SidStart)))
					continue;

				// 
				// STEP 13: 把ACE加入到新的DACL中
				//    下面的代码中，注意 AddAce 函数的第三个参数，这个参数的意思是 
				// ACL中的索引值，意为要把ACE加到某索引位置之后，参数MAXDWORD的
				// 意思是确保当前的ACE是被加入到最后的位置。
				//
				if (!AddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,((PACE_HEADER) pTempAce)->AceSize)) {
					_tprintf(TEXT("AddAce() failed. Error %d/n"), GetLastError());
					__leave;
				}

				newAceIndex++;
			}
		}

		// 
		// STEP 14: 把一个 access-allowed 的ACE 加入到新的DACL中
		//     前面的循环拷贝了所有的非继承且SID为其它用户的ACE，退出循环的第一件事
		// 就是加入我们指定的ACE。请注意首先先动态装载了一个AddAccessAllowedAceEx
		// 的API函数，如果装载不成功，就调用AddAccessAllowedAce函数。前一个函数仅
		// 在Windows 2000以后的版本支持，NT则没有，我们为了使用新版本的函数，我们首
		// 先先检查一下当前系统中可不可以装载这个函数，如果可以则就使用。使用动态链接
		// 比使用静态链接的好处是，程序运行时不会因为没有这个API函数而报错。
		// 
		// Ex版的函数多出了一个参数AceFlag（第三人参数），用这个参数我们可以来设置一
		// 个叫ACE_HEADER的结构，以便让我们所设置的ACE可以被其子目录所继承下去，而 
		// AddAccessAllowedAce函数不能定制这个参数，在AddAccessAllowedAce函数
		// 中，其会把ACE_HEADER这个结构设置成非继承的。
		// 
		_AddAccessAllowedAceEx = (AddAccessAllowedAceExFnPtr)GetProcAddress(GetModuleHandle(TEXT("advapi32.dll")),"AddAccessAllowedAceEx");

		if (_AddAccessAllowedAceEx) {
			if (!_AddAccessAllowedAceEx(pNewACL, ACL_REVISION2,CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE ,dwAccessMask, pUserSID)) {
				_tprintf(TEXT("AddAccessAllowedAceEx() failed. Error %d/n"), GetLastError());
				__leave;
			}
		}else{
			if (!AddAccessAllowedAce(pNewACL, ACL_REVISION2, dwAccessMask, pUserSID)) {
				_tprintf(TEXT("AddAccessAllowedAce() failed. Error %d/n"), GetLastError());
				__leave;
			}
		}

		// 
		// STEP 15: 按照已存在的ACE的顺序拷贝从父目录继承而来的ACE
		// 
		if (fDaclPresent && AclInfo.AceCount) {
			for (; CurrentAceIndex < AclInfo.AceCount;CurrentAceIndex++) {
				// 
				// STEP 16: 从文件（目录）的DACL中继续取ACE
				// 
				if (!GetAce(pACL, CurrentAceIndex, &pTempAce)) {
					_tprintf(TEXT("GetAce() failed. Error %d/n"), GetLastError());
					__leave;
				}

				// 
				// STEP 17: 把ACE加入到新的DACL中
				// 
				if (!AddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,((PACE_HEADER) pTempAce)->AceSize)) {
					_tprintf(TEXT("AddAce() failed. Error %d/n"), GetLastError());
					__leave;
				}
			}
		}

		// 
		// STEP 18: 把新的ACL设置到新的SD中
		// 
		if (!SetSecurityDescriptorDacl(&newSD, TRUE, pNewACL, FALSE)) {
			_tprintf(TEXT("SetSecurityDescriptorDacl() failed. Error %d/n"),GetLastError());
			__leave;
		}

		// 
		// STEP 19: 把老的SD中的控制标记再拷贝到新的SD中，我们使用的是一个叫 
		// SetSecurityDescriptorControl() 的API函数，这个函数同样只存在于
		// Windows 2000以后的版本中，所以我们还是要动态地把其从advapi32.dll 
		// 中载入，如果系统不支持这个函数，那就不拷贝老的SD的控制标记了。
		// 
		_SetSecurityDescriptorControl =(SetSecurityDescriptorControlFnPtr)GetProcAddress(GetModuleHandle(TEXT("advapi32.dll")),"SetSecurityDescriptorControl");
		if (_SetSecurityDescriptorControl) {

			SECURITY_DESCRIPTOR_CONTROL controlBitsOfInterest = 0;
			SECURITY_DESCRIPTOR_CONTROL controlBitsToSet = 0;
			SECURITY_DESCRIPTOR_CONTROL oldControlBits = 0;
			DWORD dwRevision = 0;

			if (!GetSecurityDescriptorControl(pFileSD, &oldControlBits, &dwRevision)) {
				_tprintf(TEXT("GetSecurityDescriptorControl() failed. Error %d/n"), GetLastError());
				__leave;
			}

			if (oldControlBits & SE_DACL_AUTO_INHERITED) {
				controlBitsOfInterest =
					SE_DACL_AUTO_INHERIT_REQ |
					SE_DACL_AUTO_INHERITED ;
				controlBitsToSet = controlBitsOfInterest;
			}
			else if (oldControlBits & SE_DACL_PROTECTED) {
				controlBitsOfInterest = SE_DACL_PROTECTED;
				controlBitsToSet = controlBitsOfInterest;
			}       

			if (controlBitsOfInterest) {
				if (!_SetSecurityDescriptorControl(&newSD,controlBitsOfInterest,controlBitsToSet)) {
					_tprintf(TEXT("SetSecurityDescriptorControl() failed. Error %d/n"), GetLastError());
					__leave;
				}
			}
		}

		// 
		// STEP 20: 把新的SD设置设置到文件的安全属性中（千山万水啊，终于到了）
		// 
		if (!SetFileSecurity(lpszFileName, secInfo,&newSD)) {
			_tprintf(TEXT("SetFileSecurity() failed. Error %d/n"), GetLastError());
			__leave;
		}

		fResult = TRUE;

	} 
	__finally 
	{
		// 
		// STEP 21: 释放已分配的内存，以免Memory Leak
		// 
		if (pUserSID)  myheapfree(pUserSID);
		if (szDomain)  myheapfree(szDomain);
		if (pFileSD) myheapfree(pFileSD);
		if (pNewACL) myheapfree(pNewACL);
	}

	return fResult;
}