using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Security;
using System.Security.Principal;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Web;
using System.Web.Security;
namespace Impersonate
{
[StructLayout(LayoutKind.Sequential,CharSet=CharSet.Auto)]
struct _USE_INFO_2
{
internal string ui2_local;
internal string ui2_remote;
internal IntPtr ui2_password; // don't pass a string or StringBuilder here!!
internal uint ui2_status;
internal uint ui2_asg_type;
internal uint ui2_refcount;
internal uint ui2_usecount;
internal string ui2_username;
internal string ui2_domainname;
}
class WinNet
{
[DllImport("netapi32", CharSet=CharSet.Auto, SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern int NetUseAdd(
string UncServerName, // not used
int Level, // use info struct level 1 or 2
IntPtr Buf, // Buffer
ref int ParmError
);
const uint USE_WILDCARD = 0xFFFFFFFF;
// Establish a use record
public static void UseRecord(string resource, string user, string
password, string domain)
{
int ret = 0;
int paramError = 0;
_USE_INFO_2 use2 = new _USE_INFO_2();
IntPtr pBuf = IntPtr.Zero;
use2.ui2_password = IntPtr.Zero;
try
{
pBuf = Marshal.AllocHGlobal(Marshal.SizeOf(use2));
use2.ui2_local = null;
use2.ui2_asg_type = USE_WILDCARD;
use2.ui2_remote = resource;
use2.ui2_password = Marshal.StringToHGlobalAuto(password);
use2.ui2_username = user;
use2.ui2_domainname = domain;
Marshal.StructureToPtr(use2, pBuf, true);
ret = NetUseAdd(null, 2, pBuf, ref paramError);
if(ret != 0)
{
throw new Exception(new
Win32Exception(Marshal.GetLastWin32Error()).Message);
}
}
finally
{
Marshal.FreeHGlobal(use2.ui2_password);
Marshal.FreeHGlobal(pBuf);
}
}
}
class Program
{
[System.Runtime.InteropServices.DllImport("advapi32.dll")]
public static extern int LogonUser(String lpszUserName,
String lpszDomain,
String lpszPassword,
int dwLogonType,
int dwLogonProvider,
ref IntPtr phToken);
[DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern int DuplicateToken(IntPtr hToken,
int impersonationLevel,
ref IntPtr hNewToken);
[DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern bool RevertToSelf();
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern bool CloseHandle(IntPtr handle);
const int LOGON32_PROVIDER_DEFAULT = 0;
const int LOGON32_LOGON_INTERACTIVE = 2;
static public WindowsImpersonationContext wic;
//static void Main(string[] args)
//{
// IntPtr lnToken;
// if (ImpersonateValidUser("michaell", "cmp-0641", "wilma"))
// {
// using (wic)
// {
// string dir = @"\\cmp-0641\C$\" + "Test";
// System.IO.Directory.CreateDirectory(dir);
// }
// StringBuilder sb = new StringBuilder(80, 80);
// RevertToSelf();
// //CloseHandle( lnToken );
// }
// else
// {
// }
// return;
//}
static public bool ImpersonateValidUser(String userName, String domain, String password)
{
WindowsIdentity wi;
IntPtr token = IntPtr.Zero;
IntPtr tokenDuplicate = IntPtr.Zero;
if (RevertToSelf())
{
if (LogonUser(userName, domain, password, LOGON32_LOGON_INTERACTIVE,
LOGON32_PROVIDER_DEFAULT, ref token) != 0)
{
if (DuplicateToken(token, 2, ref tokenDuplicate) != 0)
{
wi = new WindowsIdentity(tokenDuplicate);
wic = wi.Impersonate();
if (wic != null)
{
CloseHandle(token);
CloseHandle(tokenDuplicate);
return true;
}
}
}
}
if (token != IntPtr.Zero)
CloseHandle(token);
if (tokenDuplicate != IntPtr.Zero)
CloseHandle(tokenDuplicate);
return false;
}
}
public class LogOnUser
{
//LogonUser parameters
[DllImport("advapi32.dll")]
private static extern bool LogonUser(String lpszUsername,
String lpszDomain,
String lpszPassword,
int dwLogonType,
int dwLogonProvider,
ref IntPtr phToken);
//CloseHandle parameters. When you are finished,
//free the memory allocated for the handle.
[DllImport("kernel32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
private static extern bool CloseHandle(IntPtr handle);
public static WindowsIdentity GetWindowsIdentity(string pUserName, string pDomain)
{
return null;
}
public static WindowsIdentity GetWindowsIdentity(string pUserName, string pDomain, string pPassword)
{
IntPtr tokenHandle = IntPtr.Zero;
try
{
const int LOGON32_PROVIDER_DEFAULT = 0;
const int LOGON32_LOGON_NETWORK = 5;
//Call LogonUser to obtain a
//handle to an access token
bool returnValue = LogonUser(pUserName, pDomain,
pPassword,
LOGON32_LOGON_NETWORK,
LOGON32_PROVIDER_DEFAULT,
ref tokenHandle);
if (false == returnValue)
{
return null;
}
////Check the identity
//Console.WriteLine("Before impersonation: " +
// WindowsIdentity.GetCurrent().Name);
//Create a WindowsIdentity from the impersonation
//token, then impersonate the user.
WindowsIdentity newId;
newId = new WindowsIdentity(tokenHandle);
return newId;
}
catch (Exception ex)
{
// TODO log the Exception Message.
return null;
}
}
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
using System.Web;
using System.Runtime.InteropServices;
using System.Web.Security;
using System.Security.Principal;
namespace Yintai.ERP.Common.utils
{
/// <summary>
/// 模拟windows用户登陆
/// 在使用文件直接拷贝的方式向其它服务器同步文件时，需要用到其它服务器的帐号密码
/// 该实现了在文件操作时登陆其它服务器
/// author: sxd 2009-10-25
/// </summary>
public class IdentityScope : IDisposable
{
// obtains user token
[DllImport("advapi32.dll", SetLastError = true)]
static extern bool LogonUser(string pszUsername, string pszDomain, string pszPassword,
int dwLogonType, int dwLogonProvider, ref IntPtr phToken);
// closes open handes returned by LogonUser
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
extern static bool CloseHandle(IntPtr handle);
[DllImport("Advapi32.DLL")]
static extern bool ImpersonateLoggedOnUser(IntPtr hToken);
[DllImport("Advapi32.DLL")]
static extern bool RevertToSelf();
const int LOGON32_PROVIDER_DEFAULT = 0;
const int LOGON32_LOGON_NEWCREDENTIALS = 9;
const int LOGON32_LOGON_INTERACTIVE = 2; // 域控中的需要用:Interactive = 2
private bool disposed;
public IdentityScope( string sDomain)
{
string sUsername = ConfigurationManager.AppSettings["imusername"];
string sPassword = ConfigurationManager.AppSettings["impassword"];
string sSetDomain = ConfigurationManager.AppSettings["imdomain"];
// initialize tokens
IntPtr pExistingTokenHandle = new IntPtr(0);
IntPtr pDuplicateTokenHandle = new IntPtr(0);
try
{
// get handle to token
bool bImpersonated = false;
if (string.IsNullOrEmpty(sSetDomain))
{
bImpersonated = LogonUser(sUsername, sDomain, sPassword,
LOGON32_LOGON_NEWCREDENTIALS, LOGON32_PROVIDER_DEFAULT, ref pExistingTokenHandle);
}
else
{
bImpersonated = LogonUser(sUsername, sSetDomain, sPassword,
LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, ref pExistingTokenHandle);
}
if (true == bImpersonated)
{
if (!ImpersonateLoggedOnUser(pExistingTokenHandle))
{
int nErrorCode = Marshal.GetLastWin32Error();
throw new Exception("ImpersonateLoggedOnUser error;Code=" + nErrorCode);
}
}
else
{
int nErrorCode = Marshal.GetLastWin32Error();
throw new Exception("LogonUser error;Code=" + nErrorCode);
}
}
catch (Exception ex) {
throw ex;
}
finally
{
// close handle(s)
if (pExistingTokenHandle != IntPtr.Zero)
CloseHandle(pExistingTokenHandle);
if (pDuplicateTokenHandle != IntPtr.Zero)
CloseHandle(pDuplicateTokenHandle);
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
RevertToSelf();
disposed = true;
}
}
public void Dispose()
{
Dispose(true);
}
}
/// <summary>
/// 同步处理
/// 包括文件Copy，Rsync同步
/// </summary>
public class SyncHandler
{
private static object _lock = new object();
private static SyncHandler _instance = null;
private Queue<SyncParam> _queue = new Queue<SyncParam>();
private Thread[] threads = null;
private EventWaitHandle _newItemEvent;
private EventWaitHandle _exitThreadEvent;
private WaitHandle[] _eventArray;
private bool _active = true;
private SyncHandler()
{
_newItemEvent = new AutoResetEvent(false);
_exitThreadEvent = new ManualResetEvent(false);
_eventArray = new WaitHandle[2] {_newItemEvent, _exitThreadEvent};
}
public static SyncHandler Instance
{
get
{
if (_instance == null)
{
lock (_lock)
{
if (_instance == null)
{
_instance = new SyncHandler();
}
}
}
return _instance;
}
}
//启动线程
public void Start()
{
_active = true;
int count = 50;
threads = new Thread[count];
for(int i = 0; i < count; i++)
{
threads[i] = new Thread(Run);
threads[i].Start();
}
}
//停止线程
public void Stop()
{
_active = false;
_exitThreadEvent.Set();
foreach (Thread thread in threads)
{
thread.Join();
}
_exitThreadEvent.Reset();
threads = null;
}
private void Run()
{
while (_active)
{
try
{
if (_queue.Count > 0)
{
SyncParam param = null;
lock (((ICollection)_queue).SyncRoot)
{
if (_queue.Count > 0)
{
param = _queue.Dequeue();
}
}
if (param != null )
{
try
{
HandleSync(param);
}
catch (Exception ex)
{
throw ex;
}
}
}
else
{
WaitHandle.WaitAny(_eventArray);
}
}
catch (Exception exrun) {
throw exrun;
}
}
}
private void HandleSync(SyncParam param)
{
if (param == null)
{
return;
}
if (param.CopyParams != null)
{
foreach (CopyParam item in param.CopyParams)
{
if (item.DestFileName.StartsWith("\\\\"))
{
string path = item.DestFileName;
string host = path.Substring("\\\\".Length, path.IndexOf("\\", "\\\\".Length) - 2);
using (IdentityScope context = new IdentityScope(host))
{
File.Copy(item.SourceFileName, item.DestFileName, true);
}
}
else {
File.Copy(item.SourceFileName, item.DestFileName, true);
}
}
}
if (param.RsyncParams != null)
{
foreach (RsyncParam item in param.RsyncParams)
{
//Rsync(item.SavePath, item.FileUrl, item.FileName, item.SyncHost, item.SyncDir);
}
}
}
/// <summary>
/// Rsync 同步
/// </summary>
/// <param name="savePath">文档存储路径</param>
/// <param name="fileUrl">文件url地址</param>
/// <param name="fileName">文件名</param>
/// <param name="syncHost">同步主机</param>
/// <param name="syncDir">同步目录</param>
public void Rsync(string SourcePath, string FileName, string syncHost, string syncDir)
{
SyncParam param = new SyncParam();
string attPath = SourcePath + FileName;
string sourceFileName = GetRsyncFileFullPath(SourcePath, "", FileName);
string destFileName = GetRsyncFileFullPath("\\" + syncHost + "\\" + syncDir, "", FileName);
if (param.CopyParams == null)
{
param.CopyParams = new List<CopyParam>();
}
param.CopyParams.Add(new CopyParam() { SourceFileName = sourceFileName, DestFileName = destFileName });
lock (((ICollection)_queue).SyncRoot)
{
_queue.Enqueue(param);
_newItemEvent.Set();
}
}
/// <summary>
/// Rsync 同步
/// </summary>
/// <param name="SourcePath">源文件路径</param>
/// <param name="DestFilePath">目标文件路径</param>
public void Rsync(string SourcePath, string DestFilePath)
{
SyncParam param = new SyncParam();
if (param.CopyParams == null)
{
param.CopyParams = new List<CopyParam>();
}
param.CopyParams.Add(new CopyParam() { SourceFileName = SourcePath, DestFileName = DestFilePath });
lock (((ICollection)_queue).SyncRoot)
{
_queue.Enqueue(param);
_newItemEvent.Set();
}
}
/// <summary>
/// 获取完整的文件路径
/// </summary>
/// <param name="configPath"></param>
/// <param name="attPath"></param>
/// <param name="fileName"></param>
/// <returns></returns>
private string GetRsyncFileFullPath(string configPath, string attPath, string fileName)
{
string fullPath = "";
if (attPath.Length > 0)
{
fullPath = configPath + attPath;
}
else
{
if (!fullPath.EndsWith("\\"))
{
fullPath = configPath + "\\";
}
}
CheckIsExitsDir(fullPath);
return fullPath + fileName;
}
/// <summary>
/// 判断路径是否存在，如果不存在则创建
/// </summary>
/// <param name="path"></param>
private void CheckIsExitsDir(string path)
{
if ( path.StartsWith("\\\\") )
{
string host = path.Substring("\\\\".Length, path.IndexOf("\\", "\\\\".Length) - 2);
using (IdentityScope scope = new IdentityScope( host ))
{
if (!Directory.Exists(path))
{
DirectoryHandler.creatPath(path);
}
}
}
else {
DirectoryHandler.creatPath(path);
}
}
}
class CopyParam
{
public string SourceFileName { get; set; }
public string DestFileName { get; set; }
}
class RsyncParam
{
public string SavePath { get; set; }
public string FileUrl { get; set; }
public string FileName { get; set; }
public string SyncHost { get; set; }
public string SyncDir { get; set; }
}
class SyncParam
{
public IList<CopyParam> CopyParams { get; set; }
public IList<RsyncParam> RsyncParams { get; set; }
public string FileLink { get; set; }
}
}