Pending() публичный Метод

public Pending ( ) : bool
Результат bool
Пример #1
1
        /// <summary>
        /// This method will constantly run as a thread. It currently sends a multicast to the network every second, informing
        /// computers on the network that it is there. When a client sees this, it will send a message to the server and the client
        /// will be added to the clients list.
        /// </summary>
        public static void AddClients()
        {
            clients = new List<ClientThread>();
            TcpListener serverSocket = new TcpListener(IPAddress.Any, 8888);
            serverSocket.Start();

            while (true)
            {
                TcpClient tempClientSocket = new TcpClient();
                tempClientSocket.ReceiveTimeout = 300;

                SendMulticast();

                //Check and see if a computer is trying to connect.
                //If not, then sleep, and resend multicast in a second
                if (serverSocket.Pending())
                {
                    tempClientSocket = serverSocket.AcceptTcpClient();
                    ClientThread c = new ClientThread(tempClientSocket,null);
                    clients.Add(c);
                    Console.WriteLine("Connected to " + c.GetClientIP() + " :: "+c.GetPort());
                }
                else {
                    Thread.Sleep(1000); //Sleep for a second, before sending the next multicast.
                }
            }
        }
Пример #2
1
        public ChatServer()
        {
            // create nickName & nickNameByConnect variables
            nickName = new Hashtable(100);
            nickNameByConnect = new Hashtable(100);

            // initialise chatServer with at the local IP address host on port 4296
            chatServer = new TcpListener(host, 4296);
            // check to see that the server is running

            // visual indication server is running
            Console.WriteLine("Server Running");

            //keep running
            while (true)
            {
                // start the server
                chatServer.Start();

                // if there are connections pending
                if (chatServer.Pending())
                {
                    // accept the connection
                    Chat.Sockets.TcpClient chatConnection = chatServer.AcceptTcpClient();
                    // display message to client
                    Console.WriteLine("You are now connected");
                    // create a new DoCommunicate object
                    DoCommunicate comm = new DoCommunicate(chatConnection);
                }
            }
        }
Пример #3
1
        public void NoChannelForkGroup()
        {
            using (ShortcutTestClass shortcutTestClass = ParallelizationFactory.GetParallelized<ShortcutTestClass>())
            {
                TcpListener tcpListener = new TcpListener(IPAddress.Loopback, 23000);
                tcpListener.Start();

                shortcutTestClass.NoChannelForkGroup("Test");

                int i = 0;
                while (!tcpListener.Pending())
                {
                    Thread.Sleep(100);
                    if (i++ > 20)
                    {
                        tcpListener.Stop();
                        throw new TimeoutException();
                    }
                }

                TcpClient tcpClient = tcpListener.AcceptTcpClient();
                Expect(new StreamReader(tcpClient.GetStream()).ReadToEnd(), EqualTo("Test"));

                tcpClient.Close();
                tcpListener.Stop();
            }
        }
Пример #4
0
            static private void ListenHandler()
            {
                var myIP        = Communication.GetLocalIP();
                var epLocal     = new System.Net.IPEndPoint(myIP, TCPPort);
                var tcpListener = new System.Net.Sockets.TcpListener(epLocal);

                tcpListener.Start();

                while (IsListening)
                {
                    System.Threading.Thread.Sleep(1000);
                    if (tcpListener.Pending())
                    {
                        var tcpClient = tcpListener.AcceptTcpClient();
                        var netStream = tcpClient.GetStream();
                        var buffer    = new byte[1024];
                        if (!netStream.DataAvailable)
                        {
                            continue;
                        }

                        List <byte> bufferTotal = new List <byte>();
                        while (netStream.DataAvailable)
                        {
                            netStream.Read(buffer, 0, 1024);
                            bufferTotal.AddRange(buffer);
                        }
                        tcpClient.Close();
                        netStream.Close();
                        var receive = System.Text.Encoding.UTF8.GetString(bufferTotal.ToArray());
                        Owner.Invoke(DgGetMsg, receive);
                    }
                }
                tcpListener.Stop();
            }
Пример #5
0
 public Chatserver()
 {
     //create our nickname and nickname by connection variables
         nickName = new Hashtable(100);
         nickNameByConnect = new Hashtable(100);
         //create our TCPListener object
         chatServer = new System.Net.Sockets.TcpListener(4296);
         //check to see if the server is running
         //while (true) do the commands
         while (true)
         {
             //start the chat server
             chatServer.Start();
             //check if there are any pending connection requests
             if (chatServer.Pending())
             {
                  //if there are pending requests create a new connection
                 Chat.Sockets.TcpClient chatConnection = chatServer.AcceptTcpClient();
                 //display a message letting the user know they're connected
                 Console.WriteLine("You are now connected");
                 //create a new DoCommunicate Object
                 DoCommunicate comm = new DoCommunicate(chatConnection);
             }
         }
 }
Пример #6
0
 public void StartThread()
 {
     Print("Server started");
     var listner=new TcpListener(IPAddress.Any, port);
     listner.Start();
     CvarcClient cvarcClient = null;
     while(true)
     {
         while (!listner.Pending())
         {
             if (exitRequest)
             {
                 if (cvarcClient != null)
                     cvarcClient.Close();
                 listner.Stop();
                 return;
             }
             Thread.Sleep(1);
         }
         var client = listner.AcceptTcpClient();
         Print("Client accepted");
         if (cvarcClient != null)
             cvarcClient.Close(); // этот метод должен внутри CvarcClient устанавливать флаг, при котором цикл внутри Read заканчивается исключением
         cvarcClient = new CvarcClient(client);
         if (ClientConnected != null)
             ClientConnected(cvarcClient);
     }
 }
Пример #7
0
        static void Main(string[] args)
        {
            var settings = ConfigurationManager.AppSettings;
            var port = settings["COM_PORT"];
            var speed = Convert.ToInt32(settings["COM_SPEED"]);
            var tcpPort = Convert.ToInt32(settings["TCP_PORT"]);
            serial = new SerialManager(port, speed);
            Console.WriteLine("UART: " + port + " - " + speed);
            server = new HardwareTcpServer(tcpPort);
            server.OnServerState += server_OnServerState;
            server.OnClientState += server_OnClientState;
            server.OnData += server_OnData;
            serial.OnReceive += serial_OnReceive;
            serial.OnStateChange += serial_OnStateChange;
            serial.Connect();

           // bridge = new HttpToUartBridge(6200);

            TcpListener listener = new TcpListener(IPAddress.Parse("188.127.233.35"), tcpPort);
            listener.Start();
            Console.WriteLine("TCP: " + tcpPort);
            while (Thread.CurrentThread.ThreadState == ThreadState.Running)
            {
                Console.WriteLine("Listening " + tcpPort);
                while (!listener.Pending())
                {
                    Thread.Sleep(300);
                }
                server.AcceptTcpClient(listener.AcceptSocket());
            }
            Console.WriteLine("Stopped");
            listener.Stop();
            server.Close();
            serial.Close();
        }
        private void Listen()
        {
            TcpListener tcpListener = new TcpListener(IPAddress.Any, ListenPort);
            tcpListener.Start();
            TcpClient client = null;
            try
            {
                while (!CloseClass)
                {
                    if (!tcpListener.Pending())
                    {
                        Thread.Yield();
                    }
                    else
                    {
                        client = tcpListener.AcceptTcpClient();
                        ThreadPool.QueueUserWorkItem(x => returnMethod(client));
                    }
                }
            }
            finally
            {
                if (client != null)
                {
                    client.Close();
                }

                tcpListener.Stop();
            }
        }
Пример #9
0
 public void run()
 {
     Debug.Log("ACCEPTOR THREAD: Starting Tcp Listener");
     try
     {
         tcpListener = new TcpListener(IPAddress.Any, 4444);
         tcpListener.Start ();
         //new Thread (new ThreadStart (DiscoveryThread.Instance.run)).Start();
         Debug.Log("ACCEPTOR THREAD: Waiting for clients...");
         while (_isRunning) {
             while (!tcpListener.Pending()) {
                 Thread.Sleep (1000);
             }
             Debug.Log("ACCEPTOR THREAD: Client accepted!");
             ConnectionThread newconnection = new ConnectionThread(tcpListener);
             runningConnections.Add(newconnection);
             new Thread (new ThreadStart (newconnection.HandleConnection)).Start();
             Thread.Sleep(100);
         }
     }
     catch (Exception e)
     {
         Debug.LogError (e.ToString());
     }
     Debug.Log("ACCEPTOR THREAD: TCP Requesting Stop from " + runningConnections.Count + " open connections");
     foreach (ConnectionThread connection in runningConnections) {
         connection.RequestStop();
     }
     Debug.Log("ACCEPTOR THREAD: Ending...");
 }
Пример #10
0
 private void ServerThread()
 {
     try
     {
         while (serverFlg == true)
         {
             Console.WriteLine("ServerThread");
             // ソケット接続待ち
             if (listener.Pending()) //接続待ちがあれば
             {
                 TcpClient myTcpClient = listener.AcceptTcpClient();
                 // クライアントから接続有り
                 //if(myTcpClient)
                 // クライアント送受信オブジェクト生成
                 client        = new ClientTcpIp();
                 client.objSck = myTcpClient;
                 client.objStm = myTcpClient.GetStream();
                 // クライアントとの送受信開始
                 client.readFlg = true;
                 if (serverFlg == true)
                 {
                     clientThread = new Thread(
                         new ThreadStart(client.ReadWrite));
                     clientThread.Start();
                 }
             }
         }
         Console.WriteLine("STOP Server");
     }
     catch { }
 }
Пример #11
0
        public static void ReceiveTCP(int portN)
        {
            TcpListener Listener = null;
            try
            {
                Listener = new TcpListener(IPAddress.Any, portN);
                Listener.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            int BufferSize = 4096;
            byte[] RecData = new byte[BufferSize];
            int RecBytes;

            for (; ; )
            {
                TcpClient client = null;
                NetworkStream netstream = null;
                //Status = string.Empty;
                try
                {
                    string message = "Accept the Incoming File ";
                    string caption = "Incoming Connection";
                    //MessageBoxButtons buttons = MessageBoxButtons.YesNo;
                    //DialogResult result;

                    if (Listener.Pending())
                    {
                        client = Listener.AcceptTcpClient();
                        netstream = client.GetStream();
                        //Status = "Connected to a client\n";
                        //result = MessageBox.Show(message, caption, buttons);
                        Console.WriteLine("Connected to a sender");
                        string dirPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
                        string SaveFileName = dirPath+"\\"+string.Format("RecvdFile-{0:yyyy-MM-dd_hh-mm-ss-tt}", DateTime.Now);
                            if (SaveFileName != string.Empty)
                            {
                                int totalrecbytes = 0;
                                FileStream Fs = new FileStream(SaveFileName, FileMode.OpenOrCreate, FileAccess.Write);
                                while ((RecBytes = netstream.Read(RecData, 0, RecData.Length)) > 0)
                                {
                                    Fs.Write(RecData, 0, RecBytes);
                                    totalrecbytes += RecBytes;
                                }
                                Fs.Close();
                            }
                            netstream.Close();
                            client.Close();

                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    //netstream.Close();
                }
            }
        }
Пример #12
0
        /// <summary>
        ///   Monitor pentru starea firului de execuţie de rezolvare a cererilor.
        /// </summary>
        //private ManualResetEvent tcpClientConnected;
        /// <param name="iTransformer">Transformatorul de cereri în răspuns</param>
        /// <param name="port">Portul pe care se ascultă</param>
        public Replyer(ITransformer iTransformer, int port)
        {
            this.iTransformer = iTransformer;

            TcpListener tcpl = new TcpListener(IPAddress.Any, port);

            tcpl.Start();

            while (true) {

                try {

                    while (!tcpl.Pending()) {

                        Thread.Sleep(1000);
                    }

                    TcpClient client = tcpl.AcceptTcpClient();

                    ThreadPool.QueueUserWorkItem(receiveTransformAndSendFeedback, client);
                }
                catch (ThreadAbortException) {

                    tcpl.Stop();

                    return;
                }
            }
        }
Пример #13
0
        public static void Start(int port)
        {
            TcpListener listener = new TcpListener (IPAddress.Loopback, port);
            listener.Start ();

            while (run) {
                while (!listener.Pending() && run) {
                    Thread.Sleep (200);
                }

                if (!run)
                    break;

                Socket newSocket = listener.AcceptSocket ();

                Thread thread = new Thread (new ParameterizedThreadStart (Handshaker));

                int id = 0;
                lock (serviceThreads) {
                    id = serviceThreads.Count > 0 ? serviceThreads.Keys.Max () + 1 : 0;
                    serviceThreads.Add (id, thread);
                }

                thread.Start (new object[] { id, newSocket });
            }
        }
Пример #14
0
 public void Listen(int port)
 {
     TcpListener serverSocket = new TcpListener(IPAddress.Parse("127.0.0.1"), port);
     TcpClient clientSocket = default(TcpClient);
     serverSocket.Start();
     Console.WriteLine(" >> Server Started");
     try
     {
         while (true)
         {
             if (serverSocket.Pending())
             {
                 clientSocket = serverSocket.AcceptTcpClient();
                 ThreadPool.QueueUserWorkItem(o => ProcessRequest(clientSocket));
             }
             else
             {
                 Thread.Sleep(100);
             }
         }
     }
     catch (ThreadAbortException)
     {
         Console.WriteLine(" >> Server Ended");
         t = null;
     }
 }
Пример #15
0
        public void Listen()
        {
            TcpListener listener = new TcpListener(IPAddress.Any,
                Convert.ToInt32(ConfigurationManager.AppSettings["tcpPort"]));
            try
            {
                listener.Start();
                int clientNr = 0;
                OnLogged("Waiting for a connection...");
                while (continueProcess)
                {
                    if (listener.Pending())
                    {
                        TcpClient handler = listener.AcceptTcpClient();

                        if (handler != null)
                        {
                            OnLogged("Client #{0} accepted", ++clientNr);

                            ClientHandler client = new ClientHandler(handler);
                            client.Logged += Logged;
                            connectionPool.Enqueue(client);
                        }
                    }

                    Thread.Sleep(100);
                }
            }
            finally
            {
                listener.Stop();
            }
        }
Пример #16
0
        public void MassiveInvoke()
        {
            using (ChordTestClass chordTestClass = ParallelizationFactory.GetParallelized<ChordTestClass>())
            {
                List<TcpListener> tcpListeners = new List<TcpListener>();

                for (int i = 0; i < 500; i++)
                {
                    TcpListener tcpListener = new TcpListener(IPAddress.Loopback, 23000 + i);
                    tcpListeners.Add(tcpListener);
                    tcpListener.Start();
                    chordTestClass.TestMethod4(string.Format("V{0}", i));
                    chordTestClass.TestMethod5(i);
                }

                List<string> results = new List<string>();

                foreach (TcpListener tcpListener in tcpListeners)
                {
                    int i = 0;
                    var timeout = 10;
                    while (!tcpListener.Pending())
                    {
                        Thread.Sleep(100);
                        if (++i > timeout)
                        {
                            tcpListener.Stop();
                            throw new TimeoutException();
                        }
                    }

                    TcpClient tcpClient = tcpListener.AcceptTcpClient();
                    results.Add(new BinaryReader(tcpClient.GetStream()).ReadString());

                    tcpClient.Close();
                    tcpListener.Stop();
                }

                Debug.Print(string.Format("Received {0} results.", results.Count));

                List<string> results1 = new List<string>();
                List<string> results2 = new List<string>();

                foreach(string value in results)
                {
                    string[] values = value.Split(',');
                    results1.Add(values[0]);
                    results2.Add(values[1]);
                }

                for (int i = 0; i < 500; i++)
                {
                    Expect(results1.Contains(string.Format("V{0}", i)),
                           string.Format("Missing value1: {0}", i));
                    Expect(results2.Contains(string.Format("{0}", 23000 + i)),
                           string.Format("Missing value2: {0}", i));
                }

            }
        }
Пример #17
0
        public void startServer()
        {
            run = true;
            IPHostEntry host;
            string localIP = "";
            host = Dns.GetHostEntry(Dns.GetHostName());
            foreach (IPAddress ip in host.AddressList)
            {
                if (ip.AddressFamily == AddressFamily.InterNetwork)
                {
                    localIP = ip.ToString();
                }
            }
            TcpListener serverSocket = new TcpListener(IPAddress.Parse(localIP), 10000);
            TcpClient clientSocket = default(TcpClient);
            clientList = new List<ClientHandler>();

            int counter = 0;

            serverSocket.Start();
            Console.WriteLine(" >> " + "Server Started @ "+localIP);

            counter = 0;
            while (run)
            {
                if (!serverSocket.Pending())
                {
                    Thread.Sleep(500);
                    continue;
                }
                else
                {
                    counter += 1;
                    clientSocket = serverSocket.AcceptTcpClient();
                    Console.WriteLine(" >> " + "Client No:" + Convert.ToString(counter) + " has connected");
                    ClientHandler client = new ClientHandler();
                    clientList.Add(client);
                    client.startClient(clientSocket, Convert.ToString(counter));
                    client.newMessageToSend = messageHandler;
                    startClientThread();
                }
            }
            //kill the client threads
            if (!run)
            {
                foreach (ClientHandler element in clientList)
                {
                    if(element != null && element.running == true)
                    {
                            element.running = false;
                    }
                }
            }
            serverSocket.Stop();
            Console.WriteLine(" >> " + "exit");
            Console.ReadLine();
        }
Пример #18
0
        static void Main(string[] args)
        {
            ServerConfig.ParseConfig(args);
            Logger.InitWithName(ServerConfig.Name);
            Thread.CurrentThread.Name = "SERVER";

            var slave = new TcpListener(ServerConfig.ListenPort);

            try
            {
                try
                {
                    slave.Start(10);
                }
                catch
                {
                    throw new Exception(@"Невозможно открыть сокет №" + ServerConfig.ListenPort.ToString());
                }

                while (true)
                {
                    TcpClient connect = null;
                    if (slave.Pending())
                    {
                        try
                        {
                            connect = slave.AcceptTcpClient();
                        }
                        catch
                        {
                        }
                    }

                    if (connect == null) {Thread.Sleep(500);  continue;}
                    if (connect.Connected)
                    {
                        Terminal terminal = new Terminal(connect);
                        Thread thread = new Thread(Terminal.DoWork);
                        thread.Start(terminal);
                    }
                    Thread.Sleep(0);
                }
            }
            catch (OutOfMemoryException e)
            {
                Logger.WriteMessage(Logger.EventID.ServiceCrash, @"ПЕРЕПОЛНЕНИЕ ВИРТУАЛЬНОЙ ПАМЯТИ: " + e.ToString());
            }
            catch (Exception ex)
            {
                Logger.WriteMessage(Logger.EventID.ServiceCrash, ex.ToString());
            }
            finally
            {
                slave.Stop();
                Logger.Close();
            }
        }
        static void Main(string[] args)
        {
            try
            {
                // create TCP listener
                TcpListener tcpListen = new TcpListener(IPAddress.Any, 11000);
                tcpListen.Start();

                // check for a connection every two seconds
                while (!tcpListen.Pending())
                {
                    Console.WriteLine("Still listening. Will try again in 2 seconds.");
                    Thread.Sleep(2000);
                }

                using (TcpClient tcp = tcpListen.AcceptTcpClient())
                {
                    NetworkStream netStream = tcp.GetStream();

                    // create RijndaelManaged instance and encrypt
                    RijndaelManaged rm = new RijndaelManaged();

                    // set key and IV
                    //byte[] Key = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                    //             0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
                    //byte[] IV = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                    //             0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16};

                    // alternatively, generate key and IV from a shared secret (password)
                    // password and salt are inputs to key generation, which makes dictionary
                    // attacks more difficult than if the input was just the password
                    string password = "******";
                    byte[] salt = Encoding.ASCII.GetBytes("This is my salt");
                    Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(password, salt);
                    byte[] Key = key.GetBytes(rm.KeySize / 8);
                    byte[] IV = key.GetBytes(rm.BlockSize / 8);

                    CryptoStream cryptStream = new CryptoStream(netStream,
                        rm.CreateDecryptor(Key, IV),
                        CryptoStreamMode.Read);

                    using (StreamReader sReader = new StreamReader(cryptStream))
                    {
                        Console.WriteLine("The decrypted message is: {0}",
                            sReader.ReadToEnd());
                        sReader.Close();
                    }
                    tcp.Close();
                    Console.ReadKey();
                }
            }
            catch
            {
                Console.WriteLine("The listener failed");
            }
        }
Пример #20
0
        private void ListenForClientsProc(CancellationTokenSource cts)
        {
            IsListeningChanged?.Invoke(true);
            try
            {
                while (!cts.Token.IsCancellationRequested && (_server != null))
                {
                    System.Threading.Thread.Sleep(1);
                    if (IsListening && !_server.Pending())
                    {
                        continue;
                    }

                    TcpClient client = null;
                    try
                    {
                        client = _server.AcceptTcpClientAsync().Result;
                    }
                    catch (NullReferenceException)
                    {
                        break;
                    }
                    catch (ObjectDisposedException)
                    {
                        break;
                    }
                    catch (SocketException e)
                    {
                        if (e.SocketErrorCode != SocketError.Interrupted) //the server was stopped
                        {
                            Log.e("SocketException: Socket Error Code {0}: {1}\n{2}", e.SocketErrorCode,
                                  Enum.GetName(typeof(System.Net.Sockets.SocketError), e.SocketErrorCode),
                                  e.ToString());
                        }
                        break;
                    }
                    catch (Exception e)
                    {
                        Log.e(e);
                        break;
                    }
                    OnCreateClientHandler(client);
                }
            }
            catch (Exception e)
            {
                Log.e(e);
            }
            finally
            {
                IsListening = false;
                IsListeningChanged?.Invoke(IsListening);
            }
        }
Пример #21
0
        public void receiveConnection(TcpListener listener)
        {
            while (true)
            {

                if (listener.Pending())
                {
                    tcpSocket = listener.AcceptSocket();
                    return;
                }
            }
        }
Пример #22
0
        private void handleIncomingPeers()
        {
            Client peer;

            while (listener.Pending())
            {
                peer = new Client(listener.AcceptTcpClient());
                Console.WriteLine("incomming client");
                string name = peer.IPAddress + ":" + peer.Port; // figure out name
                addPeer(name, peer);                            // add them to our peers
            }
        }
Пример #23
0
 protected void Listener(object obj)
 {
     _listener = new TcpListener(IPAddress.Parse((string)Config.Configuration["IPAddress"]), (int)Config.Configuration["Port"]);
     _listener.Start(100);
     while (true)
     {
         if (_listener.Pending())
             _listener.BeginAcceptTcpClient(new AsyncCallback(AsyncResult_newcon), (object)"New Connection");
         else
             Thread.Sleep(1);
     }
 }
Пример #24
0
        public Task<KeyValuePair<string, string>?> Listen(IPAddress ip, int port, int timeout = 0, bool waitForValid = false)
        {
            return Task<KeyValuePair<string, string>?>.Factory.StartNew(() =>
                {
                    var end = DateTime.Now.AddMilliseconds(timeout);
                    TcpListener listener = null;
                    try
                    {
                        listener = new TcpListener(ip, port);
                        listener.ExclusiveAddressUse = false;
                        listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
                        listener.Server.ReceiveTimeout = timeout;
                        listener.Start();
                        do
                        {
                            if (listener.Pending())
                            {
                                using (var client = listener.AcceptTcpClient())
                                {
                                    using (var stream = new StreamReader(client.GetStream()))
                                    {
                                        var data = new byte[4096];
                                        try
                                        {
                                            var message = stream.ReadLine();
                                            var split = message.Split(':');
                                            if (split.Length == 2)
                                            {
                                                return new KeyValuePair<string, string>(split[0], split[1]);
                                            }
                                        }
                                        catch { }
                                    }
                                }
                            }
                            else if (DateTime.Now >= end)
                                return null;
                        } while (waitForValid);
                    }
                    finally
                    {
                        if (listener != null)
                        {
                            listener.Stop();
                            if (listener.Server != null)
                                listener.Server.Dispose();
                        }
                    }

                    return null;
                });
        }
Пример #25
0
 public void StartReceive()
 {
     //创建一个网络端点
     IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(ip), port);
     //创建网络监听
     lisner = new TcpListener(ipep);
     lisner.Start();
     while (true)
     {
         ////确认连接
         if (!lisner.Pending())
         {
             Thread.Sleep(1000);
             continue;
         }
         //MessageBox.Show("1");
         Socket client = lisner.AcceptSocket();
         //获得客户端节点对象
         IPEndPoint clientep = (IPEndPoint)client.RemoteEndPoint;
         //获得[文件名]
         string SendFileName = System.Text.Encoding.Unicode.GetString(TransferFiles.ReceiveVarData(client));
         //获得[包的大小]
         string bagSize = System.Text.Encoding.Unicode.GetString(TransferFiles.ReceiveVarData(client));
         //获得[包的总数量]
         int bagCount = int.Parse(System.Text.Encoding.Unicode.GetString(TransferFiles.ReceiveVarData(client)));
         //获得[最后一个包的大小]
         string bagLast = System.Text.Encoding.Unicode.GetString(TransferFiles.ReceiveVarData(client));
         //创建一个新文件
         string fileFullName = "d:\\" + SendFileName;
         FileStream MyFileStream = new FileStream(fileFullName, FileMode.Create, FileAccess.Write, FileShare.Read);
         //已发送包的个数
         int SendedCount = 0;
         while (true)
         {
             byte[] data = TransferFiles.ReceiveVarData(client);
             if (data.Length == 0)
             {
                 break;
             }
             else
             {
                 SendedCount++;
                 //将接收到的数据包写入到文件流对象
                 MyFileStream.Write(data, 0, data.Length);
             }
         }
         //关闭文件流
         MyFileStream.Close();
         //关闭套接字
         client.Close();
     }
 }
Пример #26
0
 public TalkServ() { 
     handles = new Hashtable(100); 
     handleByConnect = new Hashtable(100); 
     server = new System.Net.Sockets.TcpListener(4296); 
     while(true) { 
         server.Start(); 
         if(server.Pending()) { 
             N.Sockets.TcpClient connection = server.AcceptTcpClient(); 
             Console.WriteLine("Connection made"); 
             BackForth BF = new BackForth(connection);             
         } 
     } 
 } 
Пример #27
0
 protected void функция_потока()
 {
     TcpListener listner = null;
     try
     {
         listner = new TcpListener(5595);
         listner.Start();
         byte[] data = new byte[512];
         string str;
         PrintMsg("Wait client");
         while (true)
         {
             if (listner.Pending())
             {
                 str = null;
                 TcpClient client = listner.AcceptTcpClient();
                 PrintMsg("Connected");
                 NetworkStream stream = client.GetStream();
                 int i;
                 byte[] msgbyte = new byte[512];
                 while ((i = stream.Read(data, 0, data.Length)) != 0)
                 {
                     for (int j = 0; j < i; j++)
                         if (data[j] == 1) str += 1;
                         else
                             str += 0;
                 }
                 PrintMsg("Полученное закодированное сообщение в двоичном формате                   :\n" + str);
                 byte[] vec = new byte[str.Length];
                 for (int j = 0; j < str.Length; j++)
                     if (str[j] == '1') vec[j] = 1;
                     else
                         vec[j] = 0;
                 Hamming_Decoder hd = new Hamming_Decoder(vec);
                 hd.добавитьОшибку();
                 byte[] vec2 = hd.вернутьДанныеБезДекодирования();
                 PrintMsg("Полученное закодированное сообщение в двоичном формате с ошибкой:\n" + вСтроку(vec2));
                 vec2 = hd.декодировать(0);
                 PrintMsg("Разкодированное сообщение с ошибкой:\n" + конвертировать(vec2));
                 //PrintMsg();
                 vec = hd.декодировать(1);
                 PrintMsg("Разкодированное сообщение с исправленной ошибкой:\n" + конвертировать(vec));
                 client.Close();
                 PrintMsg("Wait client");
             }
         }
     }
     catch (SocketException e) { PrintMsg(e.Message); }
     finally { listner.Stop(); }
 }
Пример #28
0
        protected override TcpClient connectSpecific()
        {
            TcpListener host = new TcpListener(System.Net.IPAddress.Any, Global.WIFI_PORT);
            host.Start();

            while (!host.Pending() && isAlive)
                System.Threading.Thread.Sleep(200);

            TcpClient client = null;
            if(isAlive)
                client = host.AcceptTcpClient();
            host.Stop();
            return client;
        }
Пример #29
0
        public void MassiveInvoke()
        {
            using (ForkTestClass forkTestClass = ParallelizationFactory.GetParallelized<ForkTestClass>())
            {
                List<TcpListener> tcpListeners = new List<TcpListener>();

                for (int i = 0; i < 500; i++)
                {
                    TcpListener tcpListener = new TcpListener(IPAddress.Loopback, 23000 + i);
                    tcpListeners.Add(tcpListener);
                    tcpListener.Start();

                    forkTestClass.MassiveTest(i.ToString());
                }

                List<int> results = new List<int>();

                foreach (TcpListener tcpListener in tcpListeners)
                {
                int i = 0;
                    var timeout = 10;
                    while (!tcpListener.Pending())
                    {
                        Thread.Sleep(100);
                        if (++i > timeout)
                        {
                            tcpListener.Stop();
                            throw new TimeoutException();
                        }
                    }

                    if(i > timeout)
                        continue;

                    TcpClient tcpClient = tcpListener.AcceptTcpClient();
                    results.Add(new BinaryReader(tcpClient.GetStream()).ReadInt32());

                    tcpClient.Close();
                    tcpListener.Stop();
                }

                Debug.Print(string.Format("Received {0} results.", results.Count));

                for (int i = 0; i < 500; i++)
                {
                    Expect(results.Contains(i), string.Format("Missing value: {0}", i));
                }

            }
        }
Пример #30
0
		public void TcpListener ()
		{
			var port = NetworkHelpers.FindFreePort ();
			// listen with a new listener (IPv4 is the default)
			TcpListener inListener = new TcpListener (port);
			inListener.Start();
			

			// connect to it from a new socket
			IPHostEntry hostent = Dns.GetHostByAddress (IPAddress.Loopback);
			Socket outSock = null;

			foreach (IPAddress address in hostent.AddressList) {
				if (address.AddressFamily == AddressFamily.InterNetwork) {
					/// Only keep IPv4 addresses, our Server is in IPv4 only mode.
					outSock = new Socket (address.AddressFamily, SocketType.Stream,
						ProtocolType.IP);
					IPEndPoint remote = new IPEndPoint (address, port);
					outSock.Connect (remote);
					break;
				}
			}
			
			// make sure the connection arrives
			Assert.IsTrue (inListener.Pending ());
			Socket inSock = inListener.AcceptSocket ();

			// now send some data and see if it comes out the other end
			const int len = 1024;
			byte[] outBuf = new Byte [len];
			for (int i=0; i<len; i++) 
				outBuf [i] = (byte) (i % 256);

			outSock.Send (outBuf, 0, len, 0);

			byte[] inBuf = new Byte[len];
			int ret = inSock.Receive (inBuf, 0, len, 0);


			// let's see if it arrived OK
			Assert.IsTrue (ret != 0);
			for (int i=0; i<len; i++) 
				Assert.IsTrue (inBuf[i] == outBuf [i]);

			// tidy up after ourselves
			inSock.Close ();

			inListener.Stop ();
		}
Пример #31
0
 public TalkServ()
 {
     server = new System.Net.Sockets.TcpListener(85);
     Console.WriteLine("Started News Server.\nNews are:\n" + NEWS);
     while (true)
     {
         server.Start();
         if (server.Pending())
         {
             N.Sockets.TcpClient connection = server.AcceptTcpClient();
             Console.WriteLine("Connecting client!");
             BackForth BF = new BackForth(connection);
         }
     }
 }
Пример #32
0
 public Server()
 {
     listener = new TcpListener(IPAddress.Loopback, 9090);
       listener.Start();
       Console.WriteLine("Waiting for clients...");
       while (true) {
     while (!listener.Pending()) {
       Thread.Sleep(1000);
     }
     ConnectionThread newConnection = new ConnectionThread();
     newConnection.threadListener = this.listener;
     ThreadPool.QueueUserWorkItem(new
            WaitCallback(newConnection.HandleConnection));
       }
 }
        public appserver(string path)
        {
            TcpListener mylist = new TcpListener(IPAddress.Loopback, 3299);
            mylist.Start();

            while (SocialVars.Running)
            {
                if (mylist.Pending())
                {
                    Stream clientStream = mylist.AcceptTcpClient().GetStream();
                    webclient myclient = new webclient(clientStream, path);
                }
                System.Threading.Thread.Sleep(20);
            }
            mylist.Stop();
        }
Пример #34
0
 static void Main(string[] args)
 {
     MessageTypes.Init();
     tcpListener = new TcpListener(IPAddress.Any, 2594);
     tcpListener.Start();
     Console.WriteLine("Started Listening on " + IPAddress.Any.ToString());
     Thread t = new Thread(new ThreadStart(MainLoop));
     t.IsBackground = true;
     t.Start();
     while (true)
     {
     if(tcpListener.Pending())
         tcpListener.BeginAcceptTcpClient(new AsyncCallback(AcceptClientConnection), tcpListener);
     Thread.Sleep(100);
     }
 }
        private void Receive(int port)
        {
            IPAddress ip = IPAddress.Any;
            MessageBox.Show(ip.ToString());
            TcpListener listener = new TcpListener(ip, port);
            listener.Start();

            byte[] data = new byte[1024];
            int recBytes;

            while (true)
            {
                if (listener.Pending())
                {
                    client = listener.AcceptTcpClient();
                    NetworkStream nStream = client.GetStream();



                    Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
                    Nullable<bool> result = dlg.ShowDialog();
                    string filename = String.Empty;
                    if (result == true)
                    {
                        filename = dlg.FileName;
                    }


                    if (!string.IsNullOrEmpty(filename))
                    {
                        int totalrecbytes = 0;
                        FileStream Fs = new FileStream
         (filename, FileMode.OpenOrCreate, FileAccess.Write);
                        while ((recBytes = nStream.Read
             (data, 0, data.Length)) > 0)
                        {
                            Fs.Write(data, 0, recBytes);
                            totalrecbytes += recBytes;
                        }
                        Fs.Close();
                    }

                    nStream.Close();
                    client.Close();
                }
            }
        }
Пример #36
0
 private static void Listen(object state)
 {
     if (_listener.Pending())
     {
         Broadcast(_listener, new MessageEventArgs(new Message("Connection Found.")));
         System.Net.Sockets.TcpClient client = (System.Net.Sockets.TcpClient)_listener.AcceptTcpClientAsync().AsyncState;
         if (client != null)
         {
             NetworkStream ns    = client.GetStream();
             byte[]        bytes = new byte[256];
             string        data;
             int           i;
             while ((i = ns.Read(bytes, 0, bytes.Length)) != 0)
             {
                 data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
                 Broadcast(_listener, new MessageEventArgs(new Message(data)));
             }
             client.Dispose();
         }
     }
 }
Пример #37
0
        public Daemon(JobQueue queue, string hostName)
        {
            GearmanServer.Log.Info("Server listening on port 4730");

            TCPServer = new System.Net.Sockets.TcpListener(4730);
            workers   = new ConcurrentDictionary <string, List <Connection> >();

            while (true)
            {
                TCPServer.Start();

                if (TCPServer.Pending())
                {
                    try {
                        new ConnectionHandler(TCPServer.AcceptTcpClient(), queue, hostName, workers);
                    } catch (Exception e) {
                        GearmanServer.Log.Error("Exception waiting for connection: ", e);
                    }
                }

                System.Threading.Thread.Sleep(1);
            }
        }
Пример #38
0
        /// <summary> A private variation on <code>accept()</code> that also has an argument
        /// indicating that the process we are waiting for is an AIR application. If
        /// it is, then we can sometimes give slightly better error messages (see bug
        /// FB-7544).
        ///
        /// </summary>
        /// <param name="isAIRapp">if <code>true</code>, then the process we are waiting for
        /// is an AIR application. This is only used to give better error
        /// messages in the event that we can't establish a connection to
        /// that process.
        /// </param>
        private Session accept(IProgress waitReporter, bool isAIRapp)
        {
            // get timeout
            int timeout      = getPreference(SessionManager.PREF_ACCEPT_TIMEOUT);
            int totalTimeout = timeout;
            int iterateOn    = 100;

            PlayerSession session = null;

            try
            {
                m_processDead = false;
                m_serverSocket.Server.ReceiveTimeout = iterateOn;

                // Wait 100ms per iteration.  We have to do that so that we can report how long
                // we have been waiting.
                System.Net.Sockets.TcpClient s = null;
                while (s == null && !m_processDead)
                {
                    try
                    {
                        if (m_serverSocket.Pending())
                        {
                            s = m_serverSocket.AcceptTcpClient();
                        }
                        else
                        {
                            System.Threading.Thread.Sleep(iterateOn);
                            timeout -= iterateOn;
                            if (timeout < 0)
                            {
                                throw new IOException();
                            }
                        }
                    }
                    catch (IOException ste)
                    {
                        timeout -= iterateOn;
                        if (timeout < 0 || m_serverSocket == null || !m_serverSocket.Server.Connected)
                        {
                            throw ste; // we reached the timeout, or someome called stopListening()
                        }
                    }

                    // Tell the progress monitor we've waited a little while longer,
                    // so that the Eclipse progress bar can keep chugging along
                    if (waitReporter != null)
                    {
                        waitReporter.setProgress(totalTimeout - timeout, totalTimeout);
                    }
                }

                if (s == null && m_processDead)
                {
                    IOException e             = null;
                    String      detailMessage = LocalizationManager.getLocalizedTextString("processTerminatedWithoutDebuggerConnection");                //$NON-NLS-1$

                    if (m_processMessages != null)
                    {
                        String commandLineMessage = m_processMessages.ToString();
                        if (commandLineMessage.Length > 0)
                        {
                            e = new CommandLineException(detailMessage, m_launchCommand, commandLineMessage, m_processExitValue);
                        }
                    }

                    if (e == null)
                    {
                        if (isAIRapp)
                        {
                            // For bug FB-7544: give the user a hint about what might have gone wrong.
                            detailMessage += s_newline;
                            detailMessage += LocalizationManager.getLocalizedTextString("maybeAlreadyRunning");                             //$NON-NLS-1$
                        }

                        e = new IOException(detailMessage);
                    }

                    throw e;
                }

                /* create a new session around this socket */
                session = PlayerSession.createFromSocket(s);

                // transfer preferences
                session.Preferences = m_prefs;
            }
            catch (NullReferenceException)
            {
                throw new SocketException();                 //$NON-NLS-1$
            }
            finally
            {
                m_processMessages = null;
                m_launchCommand   = null;
            }

            return(session);
        }
Пример #39
0
        private void threadMethod(object threadStart)
        {
            ConfigureListener.Config config = (ConfigureListener.Config)threadStart;
            try
            {
                lock (_listenerLock)
                {
                    _listener = new System.Net.Sockets.TcpListener(config.Nic, config.Port);
                    _listener.Start();
                }
            }
            catch (Exception se)
            {
                setStatus("Error: " + se.Message);
                stopListener();
            }

            byte[] bytes = new byte[256];
            while (true)
            {
                try
                {
                    if (_listener == null)
                    {
                        return;
                    }

                    if (!_listener.Pending())
                    {
                        setStatus("Waiting for a connection... on " + _listener.LocalEndpoint);
                        Thread.Sleep(500);
                        continue;
                    }

                    using (_client = _listener.AcceptTcpClient())
                        using (NetworkStream stream = _client.GetStream())
                        {
                            setStatus(string.Format("Connected, {1} -> {0}", _client.Client.LocalEndPoint,
                                                    _client.Client.RemoteEndPoint));

                            int i;
                            while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
                            {
                                string data = config.Encoding.GetString(bytes, 0, i);

                                Dispatcher.Invoke(new Action(() => showData(data)));

                                // data = data.ToUpper();
                                // byte[] msg = Encoding.ASCII.GetBytes(data);
                                // stream.Write(msg, 0, msg.Length);
                                // Console.WriteLine("Sent: {0}", data);
                            }
                        }
                }
                catch (Exception se)
                {
                    setStatus("Error: " + se.Message);
                }
            }

//            finally
//            {
//                stopListener();
//            }
        }