Exemplo n.º 1
0
 private static void OnRecvCompleted(SocketAsyncEventArgs e)
 {
     if (RawSocket.RecvCompleted != null)
     {
         RawSocket.RecvCompleted(null, e);
     }
 }
Exemplo n.º 2
0
        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);
            RawSocket.InitRawSocket(bindEndPoint);
            RawSocket.RecvCompleted += this.ProcessRecv;

            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();
        }
Exemplo n.º 3
0
        private static void IO_Completed(object sender, SocketAsyncEventArgs e)
        {
            switch (e.LastOperation)
            {
            case SocketAsyncOperation.SendTo:
                RawSocket.ProcessSend(e);
                break;

            case SocketAsyncOperation.ReceiveFrom:
                RawSocket.ProcessRecv(e);
                break;
            }
        }
Exemplo n.º 4
0
        private static void ProcessRecv(SocketAsyncEventArgs e)
        {
            Socket sock = e.UserToken as Socket;

            if (e.SocketError == SocketError.Success && e.BytesTransferred > 0)
            {
                RawSocket.OnRecvCompleted(e);
            }
            try {
                if (!m_sock_raw.ReceiveFromAsync(e))
                {
                    IOProcessPool.QueueWork(RawSocket.ProcessRecv, e);
                }
            } catch { }
        }
Exemplo n.º 5
0
        private void CheckTimeout()
        {
            DateTime dt = DateTime.Now;
            List <SYNScanTaskInfo> lst_remove = new List <SYNScanTaskInfo>();

            while (true)
            {
                Thread.Sleep(1000);
                lst_remove.Clear();
                dt = DateTime.Now;
                bool bDisposed = base._IsDisposed;
                lock (m_dic_task_running) {
                    foreach (var v in m_dic_task_running)
                    {
                        if (!v.Value.IsStarted)
                        {
                            continue;
                        }
                        if (dt.Subtract(v.Value.StartTime).TotalMilliseconds > v.Value.TotalTimeout || bDisposed)
                        {
                            lst_remove.Add(v.Value);
                            continue;
                        }
                        if (dt.Subtract(v.Value.LastTime).TotalMilliseconds > v.Value.Timeout)
                        {
                            if (v.Value.RunedRetry++ < v.Value.Retry)
                            {
                                RawSocket.SendData(v.Value.SYNPacket, 0, v.Value.SYNPacket.Length);// this.SendData(v.Value);
                                v.Value.LastTime = DateTime.Now;
                            }
                            else
                            {
                                lst_remove.Add(v.Value);
                            }
                        }
                    }
                    foreach (var v in lst_remove)
                    {
                        this.EndTask(v);
                    }
                }
                if (bDisposed)
                {
                    break;
                }
            }
        }
Exemplo n.º 6
0
        public static void SendData(byte[] byData, int nIndex, int nLen)
        {
            SocketAsyncEventArgs sae = RawSocket.PopSAE();

            if (sae.Buffer == null || sae.Buffer.Length < nLen)
            {
                sae.SetBuffer(byData, nIndex, nLen);
            }
            else
            {
                Array.Copy(byData, nIndex, sae.Buffer, 0, nLen);
            }
            //sae.remo
            if (!m_sock_raw.SendToAsync(sae))
            {
                IOProcessPool.QueueWork(RawSocket.ProcessRecv, sae);
            }
        }
Exemplo n.º 7
0
        //private SocketAsyncEventArgs PopSAE() {
        //    lock (m_obj_sync) {
        //        if (m_que_sae.Count != 0) return m_que_sae.Dequeue();
        //    }
        //    SocketAsyncEventArgs sae = new SocketAsyncEventArgs();
        //    sae.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
        //    sae.SetBuffer(new byte[40], 0, 40);
        //    return sae;
        //}

        //private void PushSAE(SocketAsyncEventArgs sae) {
        //    lock (m_obj_sync) {
        //        if (base._IsDisposed) return;
        //        m_que_sae.Enqueue(sae);
        //    }
        //}

        protected override uint OnScan(int nPort, EndPoint endPoint, int nProbes, int nTimeout, int nRetry, int nTotalTimeout, bool bUseNullProbe)
        {
            lock (m_obj_sync) {
                if (base._IsDisposed)
                {
                    throw new ObjectDisposedException("SYNScanner", "The scanner was disposed");
                }
            }
            m_se.WaitOne();
            SYNScanTaskInfo ti = this.CreateTaskInfo(nPort, endPoint, nProbes, nTimeout, nRetry, nTotalTimeout, bUseNullProbe);

            lock (m_dic_task_running) {
                m_dic_task_running.Add(ti.TaskID, ti);
            }
            //this.SendData(ti);
            RawSocket.SendData(ti.SYNPacket, 0, ti.SYNPacket.Length);
            ti.StartTime = ti.LastTime = DateTime.Now;
            ti.IsStarted = true;
            return(ti.TaskID);
        }
Exemplo n.º 8
0
 private static void ProcessSend(SocketAsyncEventArgs e)
 {
     RawSocket.PushSAE(e);
 }