WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/canDaemon/Source/TcpServer.cs


using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Collections;
using System.IO;
 
public class TcpServer {
    private TcpListener listener;
    private bool running;
    private int port;
    private ArrayList clients;
    const byte DEBUG_LEVEL = 2; //0, 1, 2, 3
   
    private Queue tcpPackets = Queue.Synchronized(new Queue());
   
    public TcpServer(int port) {
        running = true;
        listener = new TcpListener(port);
        listener.Start();
        this.port = port;
        clients = new ArrayList();
    }
 
    public bool getData(out string data) {
        data = null;
        if (tcpPackets.Count>0) {
            data = (string)tcpPackets.Dequeue();
            return true;
        }
        return false;
    }
   
    public void thread() {
        if (DEBUG_LEVEL>1) { Console.WriteLine("Waiting for clients on port {0}", port); }
        while (running) {
            Thread.Sleep(1);
            foreach (Connection client in clients) {
                //... hämta data från client...
                //om ny data så skicka till alla i clients utom client
                string tcpdata;
                bool hasData = client.getData(out tcpdata);
                if (hasData) {
                   
                    //lägg data på kö så demonen kan hämta för vidare process
                    tcpPackets.Enqueue(tcpdata);
                   
                    //skicka data till övriga klienter, senare ska datat parsas innan så man bara skickar ut can-paket
                    foreach (Connection sendclient in clients) {
                        if (sendclient != client) {
                            sendclient.sendDataDummy(tcpdata);
                        }
                    }
                }
            }
           
            foreach (Connection client in clients) {
                if (!client.isConnected()) {
                    clients.Remove(client);
                    if (DEBUG_LEVEL>1) { Console.WriteLine("Client dropped"); }
                    break;
                }
            }
           
            if (running && listener.Pending()) {
                if (DEBUG_LEVEL>1) { Console.WriteLine("Client connected on port {0}", port); }
                TcpClient handler = listener.AcceptTcpClient();
                Connection newconn = new Connection(handler);
                clients.Add(newconn);
                Thread t = new Thread(newconn.thread);
                t.Start();
            }
        }
    }
   
    public void stop() {
        running = false;
        foreach (Connection client in clients) {
            client.stop();
        }
    }
   
    public void sendCanPacket(CanPacket cp) {
        foreach (Connection client in clients) {
            client.sendData(cp);
        }
    }
 
}
 
class Connection {
    private TcpClient client;
    private NetworkStream ns;
    private bool connected;
   
    private Queue tcpPackets = Queue.Synchronized(new Queue());
   
    public Connection(TcpClient client) {
        this.client = client;
        ns = client.GetStream();
        //this.id = id;
    }
   
    public bool getData(out string data) {
        data = null;
        if (tcpPackets.Count>0) {
            data = (string)tcpPackets.Dequeue();
            return true;
        }
        return false;
    }
   
    public void thread() {
        //läs och lagra så att en funktion kan läsa från mig
        byte[] data = new byte[1024];
        int recv;
        connected = true;
        while (connected) {
            Thread.Sleep(1);
            if (ns.DataAvailable) {
                recv = ns.Read(data, 0, data.Length);
                if (recv == 0)
                    break;
               
                string tcpdata = Encoding.ASCII.GetString(data, 0, recv);
                //string [] split = null;
                //split = tcpdata.Split(" ");
 
                //if (split.Length ) {
                    tcpPackets.Enqueue(tcpdata);
                //}
                //Console.WriteLine(System.Text.Encoding.ASCII.GetString(data));
            }
        }
        connected = false;
        ns.Close();
        client.Close();
    }
   
    public bool isConnected() {
        return connected;
    }
   
    public void stop() {
        connected = false;
    }
   
    public void sendData(CanPacket cp) {
        if (connected) {
            try {
                byte[] data = new byte[1024];
               
                data = Encoding.ASCII.GetBytes(cp.toRawString()+"\n");
                ns.Write(data, 0, data.Length);
            }
            catch (Exception) {
                connected = false;
            }
        }
    }
   
    public void sendDataDummy(string senddata) {
        if (connected) {
            try {
                byte[] data = new byte[1024];
               
                data = Encoding.ASCII.GetBytes(senddata+"\n");
                ns.Write(data, 0, data.Length);
            }
            catch (Exception) {
                connected = false;
            }
        }
    }
       
}

Rev 444	Rev 452
1	using System;	1	using System;
2	using System.Net;	2	using System.Net;
3	using System.Net.Sockets;	3	using System.Net.Sockets;
4	using System.Text;	4	using System.Text;
5	using System.Threading;	5	using System.Threading;
6	using System.Collections;	6	using System.Collections;
7	using System.IO;	7	using System.IO;
8		8
9	public class TcpServer {	9	public class TcpServer {
10	private TcpListener listener;	10	private TcpListener listener;
11	private bool running;	11	private bool running;
12	private int port;	12	private int port;
13	private ArrayList clients;	13	private ArrayList clients;
14	const byte DEBUG_LEVEL = 2; //0, 1, 2, 3	14	const byte DEBUG_LEVEL = 2; //0, 1, 2, 3
15		15
16	private Queue tcpPackets = Queue.Synchronized(new Queue());	16	private Queue tcpPackets = Queue.Synchronized(new Queue());
17		17
18	public TcpServer(int port) {	18	public TcpServer(int port) {
19	running = true;	19	running = true;
20	listener = new TcpListener(port);	20	listener = new TcpListener(port);
21	listener.Start();	21	listener.Start();
22	this.port = port;	22	this.port = port;
23	clients = new ArrayList();	23	clients = new ArrayList();
24	}	24	}
25		25
26	public bool getData(out string data) {	26	public bool getData(out string data) {
27	data = null;	27	data = null;
28	if (tcpPackets.Count>0) {	28	if (tcpPackets.Count>0) {
29	data = (string)tcpPackets.Dequeue();	29	data = (string)tcpPackets.Dequeue();
30	return true;	30	return true;
31	}	31	}
32	return false;	32	return false;
33	}	33	}
34		34
35	public void thread() {	35	public void thread() {
36	if (DEBUG_LEVEL>1) { Console.WriteLine("Waiting for clients on port {0}", port); }	36	if (DEBUG_LEVEL>1) { Console.WriteLine("Waiting for clients on port {0}", port); }
37	while (running) {	37	while (running) {
38	Thread.Sleep(10);	38	Thread.Sleep(1);
39	foreach (Connection client in clients) {	39	foreach (Connection client in clients) {
40	//... hämta data från client...	40	//... hämta data från client...
41	//om ny data så skicka till alla i clients utom client	41	//om ny data så skicka till alla i clients utom client
42	string tcpdata;	42	string tcpdata;
43	bool hasData = client.getData(out tcpdata);	43	bool hasData = client.getData(out tcpdata);
44	if (hasData) {	44	if (hasData) {
45		45
46	//lägg data på kö så demonen kan hämta för vidare process	46	//lägg data på kö så demonen kan hämta för vidare process
47	tcpPackets.Enqueue(tcpdata);	47	tcpPackets.Enqueue(tcpdata);
48		48
49	//skicka data till övriga klienter, senare ska datat parsas innan så man bara skickar ut can-paket	49	//skicka data till övriga klienter, senare ska datat parsas innan så man bara skickar ut can-paket
50	foreach (Connection sendclient in clients) {	50	foreach (Connection sendclient in clients) {
51	if (sendclient != client) {	51	if (sendclient != client) {
52	sendclient.sendDataDummy(tcpdata);	52	sendclient.sendDataDummy(tcpdata);
53	}	53	}
54	}	54	}
55	}	55	}
56	}	56	}
57		57
58	foreach (Connection client in clients) {	58	foreach (Connection client in clients) {
59	if (!client.isConnected()) {	59	if (!client.isConnected()) {
60	clients.Remove(client);	60	clients.Remove(client);
61	if (DEBUG_LEVEL>1) { Console.WriteLine("Client dropped"); }	61	if (DEBUG_LEVEL>1) { Console.WriteLine("Client dropped"); }
62	break;	62	break;
63	}	63	}
64	}	64	}
65		65
66	if (running && listener.Pending()) {	66	if (running && listener.Pending()) {
67	if (DEBUG_LEVEL>1) { Console.WriteLine("Client connected on port {0}", port); }	67	if (DEBUG_LEVEL>1) { Console.WriteLine("Client connected on port {0}", port); }
68	TcpClient handler = listener.AcceptTcpClient();	68	TcpClient handler = listener.AcceptTcpClient();
69	Connection newconn = new Connection(handler);	69	Connection newconn = new Connection(handler);
70	clients.Add(newconn);	70	clients.Add(newconn);
71	Thread t = new Thread(newconn.thread);	71	Thread t = new Thread(newconn.thread);
72	t.Start();	72	t.Start();
73	}	73	}
74	}	74	}
75	}	75	}
76		76
77	public void stop() {	77	public void stop() {
78	running = false;	78	running = false;
79	foreach (Connection client in clients) {	79	foreach (Connection client in clients) {
80	client.stop();	80	client.stop();
81	}	81	}
82	}	82	}
83		83
84	public void sendCanPacket(CanPacket cp) {	84	public void sendCanPacket(CanPacket cp) {
85	foreach (Connection client in clients) {	85	foreach (Connection client in clients) {
86	client.sendData(cp);	86	client.sendData(cp);
87	}	87	}
88	}	88	}
89		89
90	}	90	}
91		91
92	class Connection {	92	class Connection {
93	private TcpClient client;	93	private TcpClient client;
94	private NetworkStream ns;	94	private NetworkStream ns;
95	private bool connected;	95	private bool connected;
96		96
97	private Queue tcpPackets = Queue.Synchronized(new Queue());	97	private Queue tcpPackets = Queue.Synchronized(new Queue());
98		98
99	public Connection(TcpClient client) {	99	public Connection(TcpClient client) {
100	this.client = client;	100	this.client = client;
101	ns = client.GetStream();	101	ns = client.GetStream();
102	//this.id = id;	102	//this.id = id;
103	}	103	}
104		104
105	public bool getData(out string data) {	105	public bool getData(out string data) {
106	data = null;	106	data = null;
107	if (tcpPackets.Count>0) {	107	if (tcpPackets.Count>0) {
108	data = (string)tcpPackets.Dequeue();	108	data = (string)tcpPackets.Dequeue();
109	return true;	109	return true;
110	}	110	}
111	return false;	111	return false;
112	}	112	}
113		113
114	public void thread() {	114	public void thread() {
115	//läs och lagra så att en funktion kan läsa från mig	115	//läs och lagra så att en funktion kan läsa från mig
116	byte[] data = new byte[1024];	116	byte[] data = new byte[1024];
117	int recv;	117	int recv;
118	connected = true;	118	connected = true;
119	while (connected) {	119	while (connected) {
120	Thread.Sleep(20);	120	Thread.Sleep(1);
121	if (ns.DataAvailable) {	121	if (ns.DataAvailable) {
122	recv = ns.Read(data, 0, data.Length);	122	recv = ns.Read(data, 0, data.Length);
123	if (recv == 0)	123	if (recv == 0)
124	break;	124	break;
125		125
126	string tcpdata = Encoding.ASCII.GetString(data, 0, recv);	126	string tcpdata = Encoding.ASCII.GetString(data, 0, recv);
127	//string [] split = null;	127	//string [] split = null;
128	//split = tcpdata.Split(" ");	128	//split = tcpdata.Split(" ");
129		129
130	//if (split.Length ) {	130	//if (split.Length ) {
131	tcpPackets.Enqueue(tcpdata);	131	tcpPackets.Enqueue(tcpdata);
132	//}	132	//}
133	//Console.WriteLine(System.Text.Encoding.ASCII.GetString(data));	133	//Console.WriteLine(System.Text.Encoding.ASCII.GetString(data));
134	}	134	}
135	}	135	}
136	connected = false;	136	connected = false;
137	ns.Close();	137	ns.Close();
138	client.Close();	138	client.Close();
139	}	139	}
140		140
141	public bool isConnected() {	141	public bool isConnected() {
142	return connected;	142	return connected;
143	}	143	}
144		144
145	public void stop() {	145	public void stop() {
146	connected = false;	146	connected = false;
147	}	147	}
148		148
149	public void sendData(CanPacket cp) {	149	public void sendData(CanPacket cp) {
150	if (connected) {	150	if (connected) {
151	try {	151	try {
152	byte[] data = new byte[1024];	152	byte[] data = new byte[1024];
153		153
154	data = Encoding.ASCII.GetBytes(cp.toRawString()+"\n");	154	data = Encoding.ASCII.GetBytes(cp.toRawString()+"\n");
155	ns.Write(data, 0, data.Length);	155	ns.Write(data, 0, data.Length);
156	}	156	}
157	catch (Exception) {	157	catch (Exception) {
158	connected = false;	158	connected = false;
159	}	159	}
160	}	160	}
161	}	161	}
162		162
163	public void sendDataDummy(string senddata) {	163	public void sendDataDummy(string senddata) {
164	if (connected) {	164	if (connected) {
165	try {	165	try {
166	byte[] data = new byte[1024];	166	byte[] data = new byte[1024];
167		167
168	data = Encoding.ASCII.GetBytes(senddata+"\n");	168	data = Encoding.ASCII.GetBytes(senddata+"\n");
169	ns.Write(data, 0, data.Length);	169	ns.Write(data, 0, data.Length);
170	}	170	}
171	catch (Exception) {	171	catch (Exception) {
172	connected = false;	172	connected = false;
173	}	173	}
174	}	174	}
175	}	175	}
176		176
177	}	177	}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/canDaemon/Source/TcpServer.cs @ 452 – Rev 444 → 452