public static uint GetSynPacket(byte[] byBuffer, uint uSIP, uint uDIP, ushort usSPort, ushort usDPort)
{
uint uSeq = 0;
lock (m_rnd) uSeq = (uint)m_rnd.Next();
return(RAWDefine.GetSynPacket(byBuffer, uSIP, uDIP, usSPort, usDPort, uSeq));
}
public static uint GetSynPacket(byte[] byBuffer, string strSIP, string strDIP, ushort usSPort, ushort usDPort)
{
uint uSeq = 0;
lock (m_rnd) uSeq = (uint)m_rnd.Next();
return(RAWDefine.GetSynPacket(byBuffer, RAWDefine.IPToINT(strSIP), RAWDefine.IPToINT(strDIP), usSPort, usDPort, uSeq));
}
//private void SendData(SYNScanTaskInfo ti) {
// SocketAsyncEventArgs sae = this.PopSAE();
// Array.Copy(ti.SYNPacket, sae.Buffer, ti.SYNPacket.Length);
// ti.LastTime = DateTime.Now;
// sae.RemoteEndPoint = ti.EndPoint;
// if (!m_sock_raw.SendToAsync(sae)) IOProcessPool.QueueWork(this.ProcessSend, sae);
//}
private SYNScanTaskInfo CreateTaskInfo(int nPort, EndPoint endPoint, int nProbes, int nTimeout, int nRetry, int nTotalTimeout, bool bUseNullProbes)
{
SYNScanTaskInfo ti = null;
lock (m_obj_sync) {
ti = m_que_task.Dequeue();
}
ti.Retry = nRetry;
ti.RunedRetry = 0;
ti.Port = nPort;
ti.EndPoint = endPoint;
ti.IsStarted = false;
ti.Probes = nProbes;
ti.IsUseNullProbe = bUseNullProbes;
ti.Timeout = nTimeout;
ti.TotalTimeout = nTotalTimeout;
ti.UIP = BitConverter.ToUInt32(((IPEndPoint)endPoint).Address.GetAddressBytes(), 0);
uint uTemp = 0;
lock (m_rnd) uTemp = (uint)m_rnd.Next();
uTemp &= 0xFF0000FF;
ti.TaskID = ti.TaskID & 0x00FFFF00 | uTemp;
ti.SEQ = RAWDefine.GetSynPacket(ti.SYNPacket, m_uLocalIP, ti.UIP, m_nLocalPort, (ushort)ti.Port, ti.TaskID);
return(ti);
}
private void FullCheckSum(byte[] byPacket)
{
uint sum = RAWDefine.CheckSum(byPacket, byPacket.Length);
byPacket[2] = (byte)sum;
byPacket[3] = (byte)(sum >> 8);
}
//void IO_Completed(object sender, SocketAsyncEventArgs e) {
// switch (e.LastOperation) {
// case SocketAsyncOperation.SendTo:
// this.ProcessSend(e);
// break;
// case SocketAsyncOperation.Receive:
// this.ProcessRecv(e);
// break;
// }
//}
//private void ProcessSend(SocketAsyncEventArgs e) {
// this.PushSAE(e);
//}
private void ProcessRecv(object sender, SocketAsyncEventArgs e)
{
lock (m_obj_sync) {
if (base._IsDisposed)
{
return;
}
}
Socket sock = e.UserToken as Socket;
if (e.SocketError == SocketError.Success && e.BytesTransferred > 0)
{
bool b = true;
uint uSIP = BitConverter.ToUInt32(e.Buffer, 16);
int nOffset = (e.Buffer[0] & 0x0F) * 4;
uint uSEQ = RAWDefine.GetACKNumber(e.Buffer, nOffset) - 1;
if (e.BytesTransferred < 40)
{
b = false;
}
else if (nOffset < 20 || e.BytesTransferred - 20 < nOffset)
{
b = false;
}
else if (e.Buffer[9] != RAWDefine.PROTO_TCP)
{
b = false;
}
else if ((ushort)((e.Buffer[nOffset + 2] << 8) | e.Buffer[nOffset + 3]) != m_nLocalPort)
{
b = false;
}
else if (e.Buffer[nOffset + 13] != 0x12)
{
b = false; //syn + ack
}
else if (uSIP != m_uLocalIP)
{
b = false;
}
SYNScanTaskInfo ti = null;
if (b)
{
lock (m_dic_task_running) {
if (m_dic_task_running.ContainsKey(uSEQ))
{
ti = m_dic_task_running[uSEQ];
m_dic_task_running.Remove(uSEQ);
}
}
}
if (ti != null)
{
uint id = m_tcp_scanner.Scan(ti.UIP, ti.Port, ti.Probes, ti.Timeout, ti.Retry, ti.TotalTimeout, ti.IsUseNullProbe);
lock (m_dic_uid) m_dic_uid.Add(id, ti);
}
}
//if (!sock.ReceiveAsync(e)) IOProcessPool.QueueWork(this.ProcessRecv, e);
}
public SYNScanner(int nMaxTask, ProbeConfiger probes, EndPoint bindEndPoint)
{
if (nMaxTask > 60000 || nMaxTask < 1)
{
throw new ArgumentOutOfRangeException("the MaxTask must be between 1 and 30000");
}
m_probes = probes;
if (bindEndPoint == null)
{
foreach (var v in Dns.GetHostAddresses(Dns.GetHostName()))
{
if (v.IsIPv6LinkLocal || v.IsIPv6Multicast || v.IsIPv6SiteLocal)
{
continue;
}
bindEndPoint = new IPEndPoint(v, 0);
}
}
m_rnd = new Random();
m_dic_uid = new Dictionary <uint, SYNScanTaskInfo>();// new Dictionary<uint, uint>();
m_dic_task_running = new Dictionary <uint, SYNScanTaskInfo>();
m_tcp_scanner = new TCPScanner(nMaxTask, probes);
m_tcp_scanner.Completed += new ScanEventHandler(m_tcp_Completed);
m_sock_bind = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
m_sock_bind.Bind(bindEndPoint);
bindEndPoint = m_sock_bind.LocalEndPoint;
m_strLocalIP = bindEndPoint.ToString().Split(':')[0];
m_uLocalIP = RAWDefine.IPToINT(m_strLocalIP);
m_nLocalPort = ushort.Parse(bindEndPoint.ToString().Split(':')[1]);
m_se = new Semaphore(nMaxTask, nMaxTask);
m_sock_raw = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);
m_sock_raw.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, true);
m_sock_raw.Bind(bindEndPoint);
m_sock_raw.IOControl(IOControlCode.ReceiveAll, new byte[] { 1, 0, 0, 0 }, null);
m_que_task = new Queue <SYNScanTaskInfo>();
m_que_sae = new Queue <SocketAsyncEventArgs>();
for (int i = 0; i < nMaxTask; i++)
{
SYNScanTaskInfo ti = new SYNScanTaskInfo();
ti.TaskID = (uint)((i + 1) << 8);
ti.SYNPacket = new byte[40];
m_que_task.Enqueue(ti);
}
SocketAsyncEventArgs sae = new SocketAsyncEventArgs();
sae.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
sae.SetBuffer(new byte[65535], 0, 65535);
sae.UserToken = m_sock_raw;
if (!m_sock_raw.ReceiveAsync(sae))
{
IOProcessPool.QueueWork(this.ProcessRecv, sae);
}
m_thread_timeout = new Thread(this.CheckTimeout);
m_thread_timeout.IsBackground = true;
m_thread_timeout.Start();
}
public static uint GetSynPacket(byte[] byBuffer, uint uSIP, uint uDIP, ushort usSPort, ushort usDPort, uint uSeq)
{
Array.Copy(m_bySyn, byBuffer, m_bySyn.Length);
uint useq = RAWDefine.SetSynData(byBuffer, uSIP, uDIP, usSPort, usDPort, uSeq);
RAWDefine.CheckSum(byBuffer);
return(useq);
}
private static void CheckSum(byte[] bySyn)
{
lock (m_byPsd) {
m_byPsd[0] = bySyn[12];
m_byPsd[1] = bySyn[13];
m_byPsd[2] = bySyn[14];
m_byPsd[3] = bySyn[15];
m_byPsd[4] = bySyn[16];
m_byPsd[5] = bySyn[17];
m_byPsd[6] = bySyn[18];
m_byPsd[7] = bySyn[19];
Array.Copy(m_byPsd, m_byTemp, 12);
Array.Copy(bySyn, 20, m_byTemp, 12, 20);
ushort usSum = RAWDefine.CheckSum(m_byTemp, m_byTemp.Length);
bySyn[36] = (byte)(usSum);
bySyn[37] = (byte)(usSum >> 8);
usSum = RAWDefine.CheckSum(bySyn, 20);
bySyn[10] = (byte)(usSum);
bySyn[11] = (byte)(usSum >> 8);
}
}
private TaskInfo CreateTaskInfo(IPAddress ipAddr, int nRetry, byte[] byData)
{
TaskInfo ti = null;
lock (m_que_taskInfo) ti = m_que_taskInfo.Dequeue();
if (byData != null)
{
if (byData.Length > 1400)
{
throw new ArgumentException("The [byData.Length] must less than 1400");
}
if (byData.Length + ti.HeadPacket.Length > ti.TempPacket.Length)
{
ti.TempPacket = new byte[byData.Length + ti.HeadPacket.Length];
Array.Copy(ti.HeadPacket, ti.TempPacket, ti.HeadPacket.Length);
Array.Copy(byData, 0, ti.TempPacket, ti.HeadPacket.Length, byData.Length);
}
ti.DataLen = ti.HeadPacket.Length + byData.Length;
}
else
{
ti.DataLen = ti.HeadPacket.Length + 1;
Array.Copy(ti.HeadPacket, ti.TempPacket, ti.HeadPacket.Length);
lock (m_rnd) ti.TempPacket[ti.HeadPacket.Length] = (byte)m_rnd.Next('a', 'z');
}
ti.TempPacket[2] = 0;
ti.TempPacket[3] = 0;
uint sum = RAWDefine.CheckSum(ti.TempPacket, ti.TempPacket.Length);
ti.TempPacket[2] = (byte)sum;
ti.TempPacket[3] = (byte)(sum >> 8);
ti.EndPoint = new IPEndPoint(ipAddr, 0);
ti.Retry = nRetry;
ti.RunedRetry = 0;
return(ti);
}
public static uint IPToINT(string strIP)
{
return(RAWDefine.IPToINT(strIP, false));
}
public static uint GetSynPacket(byte[] byBuffer, string strSIP, string strDIP, ushort usSPort, ushort usDPort, uint uSeq)
{
return(RAWDefine.GetSynPacket(byBuffer, RAWDefine.IPToINT(strSIP), RAWDefine.IPToINT(strDIP), usSPort, usDPort, uSeq));
}
public static byte[] GetSynPacket(uint uSIP, uint uDIP, ushort usSPort, ushort usDPort, uint uSeq)
{
byte[] byRet = new byte[m_bySyn.Length];
RAWDefine.GetSynPacket(byRet, uSIP, uDIP, usSPort, usDPort, uSeq);
return(byRet);
}
public static byte[] GetSynPacket(string strSIP, string strDIP, ushort usSPort, ushort usDPort)
{
return(RAWDefine.GetSynPacket(RAWDefine.IPToINT(strSIP), RAWDefine.IPToINT(strDIP), usSPort, usDPort));
}
