Esempio n. 1
0
        public static void AcceptCallback(IAsyncResult ar)
        {
            // Signal the main thread to continue.
            allDone.Set();

            // Get the socket that handles the client request.
            Socket listener = (Socket) ar.AsyncState;
            Socket handler = listener.EndAccept(ar);

            // Create the state object.
            SocketInterfaceStateObject state = new SocketInterfaceStateObject();
            state.workSocket = handler;

            Console.WriteLine("Received Connection from {0}", handler.RemoteEndPoint);

            handler.BeginReceive(
                state.buffer,
                0,
                SocketInterfaceStateObject.BufferSize,
                0,
                new AsyncCallback(ReadCallback),
                state);
        }
Esempio n. 2
0
        public static void AcceptCallback(IAsyncResult ar)
        {
            // Signal the main thread to continue.
            allDone.Set();

            // Get the socket that handles the client request.
            Socket listener = (Socket)ar.AsyncState;
            Socket handler  = listener.EndAccept(ar);

            // Create the state object.
            SocketInterfaceStateObject state = new SocketInterfaceStateObject();

            state.workSocket = handler;

            Console.WriteLine("Received Connection from {0}", handler.RemoteEndPoint);

            handler.BeginReceive(
                state.buffer,
                0,
                SocketInterfaceStateObject.BufferSize,
                0,
                new AsyncCallback(ReadCallback),
                state);
        }
Esempio n. 3
0
        public static void ReadCallback(IAsyncResult ar)
        {
            String content = String.Empty;

            // Retrieve the state object and the handler socket
            // from the asynchronous state object.
            SocketInterfaceStateObject state = (SocketInterfaceStateObject)ar.AsyncState;
            Socket handler = state.workSocket;

            // Read data from the client socket.
            int bytesRead = handler.EndReceive(ar);

            if (bytesRead > 0)
            {
                // There  might be more data, so store the data received so far.
                state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

                // Check for end-of-file tag. If it is not there, read more data.
                content = state.sb.ToString();

                if (content.IndexOf("<EOF>") > -1)
                {
                    // Clear the string builder from state object
                    state.sb.Length = 0;

                    // All the command data has been read from the client.
                    // Display it on the console.

                    //Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",
                    //    content.Length, content );

                    content = content.Remove(content.IndexOf("<EOF>"));

                    if (content.StartsWith("READ|"))
                    {
                        content = content.Replace("READ|", "");

                        string response = content + "=" + ReadFromDataBase(content);
                        //string response = ReadRandom();

                        // Send tag value to the client
                        Send(handler, response);
                    }
                    else if (content.StartsWith("WRITE|"))
                    {
                        content = content.Replace("WRITE|", "");

                        string[] array = content.Split('|');

                        if (array.Length > 1)
                        {
                            string tagname  = array[0];
                            string tagvalue = array[1];

                            WriteToDataSource(tagname, tagvalue);
                        }
                    }
                    else
                    {
                        log.Error("Unkown command received: " + content);
                    }
                }

                // Continue to listen for commands
                handler.BeginReceive(
                    state.buffer,
                    0,
                    SocketInterfaceStateObject.BufferSize,
                    0,
                    new AsyncCallback(ReadCallback),
                    state);
            }
        }