trunk/TELTest/ConnectionHandler.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace TELTest {
    public abstract class ConnectionHandler {
        public static List<ConnectionHandler> AllHandlers { get; } = new List<ConnectionHandler>();
        public ConnectionHandler() {
            ID = AllHandlers.Count;
            AllHandlers.Add(this);
        }
        public int ID { get; protected set; }
        public abstract Task HandleMe(NetworkStream stream);
        public async Task Handle(NetworkStream stream) {
            await Task.Delay(500); // PBX flashbacks
            await WriteASCII(stream, "Processing.\r\n");
            await Task.Delay(100);
            Flush(stream);
            //await ReadTimeout(stream, 100); // Catch loose buffered chars
            await TryClear(stream);
            await WriteASCII(stream, "Hello!\r\n");
            await WriteASCII(stream, (ID + 1) + " concurrent connections right now.\r\n");
            await WriteASCII(stream, $"Server time is {DateTime.Now}\r\n");

            await HandleMe(stream);
            await WriteASCII(stream, "\r\n\r\nBye!\r\n");
            AllHandlers.Remove(this);
        }
        public void Flush(NetworkStream stream) {
            while (stream.DataAvailable) stream.ReadByte();
        }
        public int ReadOneIfAvailable(NetworkStream stream) {
            if (!stream.DataAvailable) return -1;
            return stream.ReadByte();
        }
        public async Task TryClear(NetworkStream stream) {
            await WriteASCII(stream, "\x1b[2J\x1b[H");
        }
        public async Task<char> Choice(NetworkStream stream, char[] choice, string caption = null,
            string prompt = null, char? def = null, bool echo = true, bool noNewLine = false,
            bool caseSensitive = false, CancellationToken? token = null) {
            if (choice.Length <= 0) throw new ArgumentOutOfRangeException(nameof(choice));
            
            if (prompt == null) {
                StringBuilder sb = new StringBuilder();
                sb.Append('[');
                for (int i = 0; i < choice.Length; i++) {
                    var item = choice[i];
                    string cs = (item + (i == choice.Length - 1 ? "" : "/"));
                    cs = caseSensitive ? cs : cs.ToUpper();
                    sb.Append(cs);
                }
                sb.Append(']');
                if (def != null) {
                    string cs = " (" + def.Value + ")";
                    cs = caseSensitive ? cs : cs.ToUpper();
                    sb.Append(cs);
                }
                sb.Append(" > ");
                prompt = sb.ToString();
            }
            char selection = '\0';
            while (true) {
                if (caption != null)
                    await WriteASCII(stream, "\r\n" + caption + "\r\n");
                

                await WriteASCII(stream, prompt);
                char c = await ReadChar(stream,echo);
                if (!noNewLine) await WriteASCII(stream, "\r\n");

                for (int i = 0; i < choice.Length; i++) {
                    if (caseSensitive) {
                        if (choice[i] == c) {
                            selection = c;
                            goto ChoiceDone;
                        }
                    } else {
                        if (Char.ToUpper(choice[i]) == Char.ToUpper(c)) {
                            selection = choice[i];
                            goto ChoiceDone;
                        }
                    }
                }
                if (def != null) {
                    if (c == '\r' || c == '\n') {
                        selection = def.Value;
                        //while (stream.DataAvailable) stream.ReadByte();
                        goto ChoiceDone;
                    }
                }
                Flush(stream);
            }
        ChoiceDone:;
            Flush(stream);
            return selection;
        }
        public async Task<string> Prompt(NetworkStream stream, string prompt, ReadConfiguration? config = null, Nullable<CancellationToken> token = null) {
            await WriteASCII(stream, prompt);
            if (config == null) config = ReadConfiguration.Default;
            string ret = await Read(stream, config.Value, token);
            await WriteASCII(stream, "\r\n");
            return ret;
        }
        public async Task<string> Read(NetworkStream stream, char terminator = '\r', bool echo = true, Nullable<CancellationToken> token = null) {
            ReadConfiguration rc = ReadConfiguration.Default;
            rc.Terminator = terminator;
            rc.Echo = echo;
            return await Read(stream, rc, token);
        }
        public async Task<string> Read(NetworkStream stream, ReadConfiguration config, Nullable<CancellationToken> token = null) {
            byte[] buf = new byte[512];
            int i = 0;
            int con = 0;
            while (true) {
                if (token == null)
                    await stream.ReadAsync(buf, i, 1);
                else
                    await stream.ReadAsync(buf, i, 1, token.Value);
                if (buf[i] == 0x7F) {
                    buf[i] = (byte)'\b';
                    await WriteASCII(stream, "\b");
                }

                if (buf[i] == (byte)config.Terminator) { i++;  break; }


                if (buf[i] == (byte)'\b') {
                    i--;
                    con--;
                    i = i < 0 ? 0 : i;
                    

                    if (con >= 0) {
                        await WriteASCII(stream, " \b");
                    } else if (con < 0) {
                        await WriteASCII(stream, " ");
                        con++;
                    }
                    continue;
                } else {
                    i++;
                    
                    if (!config.Echo) {
                        await WriteASCII(stream, "\b \b");
                    } else {
                        con++;
                    }
                }
                char cb = (char)buf[i - 1];
                if (config.Whitelist != null && config.Whitelist.IndexOf(cb) == -1 && (cb != '\b' && cb != '\n' && cb != '\r')) {
                    //Console.WriteLine("Forbidden char - \"" + (char)buf[i] + "\"");
                    await WriteASCII(stream, "\b \b");
                    i--;
                    con--;
                    continue;
                }
                if (config.Echo && config.EchoPasswordChars) {
                    await WriteASCII(stream, "\b" + config.PasswordChar);
                }
                if (config.MaxLength + 1 == i) {
                    i--;
                    con--;
                    await WriteASCII(stream, "\b \b");
                }
                //Console.WriteLine(buf[i > 0 ? i - 1 : 0].ToString("X") + ", " + i + " curs " + con);
            }
            string ret = System.Text.Encoding.ASCII.GetString(buf, 0, i - 1);
            if (config.FlushAfterReading) Flush(stream);
            return ret.Trim();
        }
        protected int Columns { get; set; } = 120;
        public String PlayerName { get; set; }
        public bool PlayerReady { get; set; }
        public object SharedTempUserObject { get; set; }

        public async Task<string> ReadTimeout(NetworkStream stream, int timeout, string def = null, char terminator = '\n') {
            CancellationTokenSource cts = new CancellationTokenSource();

            Task<string> ts = Read(stream, terminator, true, cts.Token);
            await Task.WhenAny(ts, Task.Delay(timeout));
            cts.Cancel();
            cts.Dispose();
            return ts.IsCompleted ? ts.Result : def;
        }
        public async Task<char> ReadChar(NetworkStream stream, bool echo = true) {
            byte[] buf = new byte[512];
            await stream.ReadAsync(buf, 0, 1);
            if (!echo && buf[0] != 8) await WriteASCII(stream, "\b \b");
            //string ret = System.Text.Encoding.ASCII.GetString(buf, 0, i - 1);
            return (char)buf[0];
        }
        public async Task WriteBar(NetworkStream stream, char chr = '=') {
            await WriteASCII(stream, new string(chr, Columns) + "\r\n");
        }
        public async Task WriteASCII(NetworkStream stream, string text) {
            var bytes = Encoding.ASCII.GetBytes(text);
            await stream.WriteAsync(bytes, 0, bytes.Length);
        }
    }
}
Revision:	2
Committed:	Wed Feb 11 13:07:01 2026 UTC (8 weeks, 3 days ago) by figdor32
File size:	8806 byte(s)
Log Message:	Initial check-in
#	Content
1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Net.Sockets;
5	using System.Text;
6	using System.Threading;
7	using System.Threading.Tasks;
8
9	namespace TELTest {
10	public abstract class ConnectionHandler {
11	public static List<ConnectionHandler> AllHandlers { get; } = new List<ConnectionHandler>();
12	public ConnectionHandler() {
13	ID = AllHandlers.Count;
14	AllHandlers.Add(this);
15	}
16	public int ID { get; protected set; }
17	public abstract Task HandleMe(NetworkStream stream);
18	public async Task Handle(NetworkStream stream) {
19	await Task.Delay(500); // PBX flashbacks
20	await WriteASCII(stream, "Processing.\r\n");
21	await Task.Delay(100);
22	Flush(stream);
23	//await ReadTimeout(stream, 100); // Catch loose buffered chars
24	await TryClear(stream);
25	await WriteASCII(stream, "Hello!\r\n");
26	await WriteASCII(stream, (ID + 1) + " concurrent connections right now.\r\n");
27	await WriteASCII(stream, $"Server time is {DateTime.Now}\r\n");
28
29	await HandleMe(stream);
30	await WriteASCII(stream, "\r\n\r\nBye!\r\n");
31	AllHandlers.Remove(this);
32	}
33	public void Flush(NetworkStream stream) {
34	while (stream.DataAvailable) stream.ReadByte();
35	}
36	public int ReadOneIfAvailable(NetworkStream stream) {
37	if (!stream.DataAvailable) return -1;
38	return stream.ReadByte();
39	}
40	public async Task TryClear(NetworkStream stream) {
41	await WriteASCII(stream, "\x1b[2J\x1b[H");
42	}
43	public async Task<char> Choice(NetworkStream stream, char[] choice, string caption = null,
44	string prompt = null, char? def = null, bool echo = true, bool noNewLine = false,
45	bool caseSensitive = false, CancellationToken? token = null) {
46	if (choice.Length <= 0) throw new ArgumentOutOfRangeException(nameof(choice));
47
48	if (prompt == null) {
49	StringBuilder sb = new StringBuilder();
50	sb.Append('[');
51	for (int i = 0; i < choice.Length; i++) {
52	var item = choice[i];
53	string cs = (item + (i == choice.Length - 1 ? "" : "/"));
54	cs = caseSensitive ? cs : cs.ToUpper();
55	sb.Append(cs);
56	}
57	sb.Append(']');
58	if (def != null) {
59	string cs = " (" + def.Value + ")";
60	cs = caseSensitive ? cs : cs.ToUpper();
61	sb.Append(cs);
62	}
63	sb.Append(" > ");
64	prompt = sb.ToString();
65	}
66	char selection = '\0';
67	while (true) {
68	if (caption != null)
69	await WriteASCII(stream, "\r\n" + caption + "\r\n");
70
71
72	await WriteASCII(stream, prompt);
73	char c = await ReadChar(stream,echo);
74	if (!noNewLine) await WriteASCII(stream, "\r\n");
75
76	for (int i = 0; i < choice.Length; i++) {
77	if (caseSensitive) {
78	if (choice[i] == c) {
79	selection = c;
80	goto ChoiceDone;
81	}
82	} else {
83	if (Char.ToUpper(choice[i]) == Char.ToUpper(c)) {
84	selection = choice[i];
85	goto ChoiceDone;
86	}
87	}
88	}
89	if (def != null) {
90	if (c == '\r' \|\| c == '\n') {
91	selection = def.Value;
92	//while (stream.DataAvailable) stream.ReadByte();
93	goto ChoiceDone;
94	}
95	}
96	Flush(stream);
97	}
98	ChoiceDone:;
99	Flush(stream);
100	return selection;
101	}
102	public async Task<string> Prompt(NetworkStream stream, string prompt, ReadConfiguration? config = null, Nullable<CancellationToken> token = null) {
103	await WriteASCII(stream, prompt);
104	if (config == null) config = ReadConfiguration.Default;
105	string ret = await Read(stream, config.Value, token);
106	await WriteASCII(stream, "\r\n");
107	return ret;
108	}
109	public async Task<string> Read(NetworkStream stream, char terminator = '\r', bool echo = true, Nullable<CancellationToken> token = null) {
110	ReadConfiguration rc = ReadConfiguration.Default;
111	rc.Terminator = terminator;
112	rc.Echo = echo;
113	return await Read(stream, rc, token);
114	}
115	public async Task<string> Read(NetworkStream stream, ReadConfiguration config, Nullable<CancellationToken> token = null) {
116	byte[] buf = new byte[512];
117	int i = 0;
118	int con = 0;
119	while (true) {
120	if (token == null)
121	await stream.ReadAsync(buf, i, 1);
122	else
123	await stream.ReadAsync(buf, i, 1, token.Value);
124	if (buf[i] == 0x7F) {
125	buf[i] = (byte)'\b';
126	await WriteASCII(stream, "\b");
127	}
128
129	if (buf[i] == (byte)config.Terminator) { i++; break; }
130
131
132	if (buf[i] == (byte)'\b') {
133	i--;
134	con--;
135	i = i < 0 ? 0 : i;
136
137
138	if (con >= 0) {
139	await WriteASCII(stream, " \b");
140	} else if (con < 0) {
141	await WriteASCII(stream, " ");
142	con++;
143	}
144	continue;
145	} else {
146	i++;
147
148	if (!config.Echo) {
149	await WriteASCII(stream, "\b \b");
150	} else {
151	con++;
152	}
153	}
154	char cb = (char)buf[i - 1];
155	if (config.Whitelist != null && config.Whitelist.IndexOf(cb) == -1 && (cb != '\b' && cb != '\n' && cb != '\r')) {
156	//Console.WriteLine("Forbidden char - \"" + (char)buf[i] + "\"");
157	await WriteASCII(stream, "\b \b");
158	i--;
159	con--;
160	continue;
161	}
162	if (config.Echo && config.EchoPasswordChars) {
163	await WriteASCII(stream, "\b" + config.PasswordChar);
164	}
165	if (config.MaxLength + 1 == i) {
166	i--;
167	con--;
168	await WriteASCII(stream, "\b \b");
169	}
170	//Console.WriteLine(buf[i > 0 ? i - 1 : 0].ToString("X") + ", " + i + " curs " + con);
171	}
172	string ret = System.Text.Encoding.ASCII.GetString(buf, 0, i - 1);
173	if (config.FlushAfterReading) Flush(stream);
174	return ret.Trim();
175	}
176	protected int Columns { get; set; } = 120;
177	public String PlayerName { get; set; }
178	public bool PlayerReady { get; set; }
179	public object SharedTempUserObject { get; set; }
180
181	public async Task<string> ReadTimeout(NetworkStream stream, int timeout, string def = null, char terminator = '\n') {
182	CancellationTokenSource cts = new CancellationTokenSource();
183
184	Task<string> ts = Read(stream, terminator, true, cts.Token);
185	await Task.WhenAny(ts, Task.Delay(timeout));
186	cts.Cancel();
187	cts.Dispose();
188	return ts.IsCompleted ? ts.Result : def;
189	}
190	public async Task<char> ReadChar(NetworkStream stream, bool echo = true) {
191	byte[] buf = new byte[512];
192	await stream.ReadAsync(buf, 0, 1);
193	if (!echo && buf[0] != 8) await WriteASCII(stream, "\b \b");
194	//string ret = System.Text.Encoding.ASCII.GetString(buf, 0, i - 1);
195	return (char)buf[0];
196	}
197	public async Task WriteBar(NetworkStream stream, char chr = '=') {
198	await WriteASCII(stream, new string(chr, Columns) + "\r\n");
199	}
200	public async Task WriteASCII(NetworkStream stream, string text) {
201	var bytes = Encoding.ASCII.GetBytes(text);
202	await stream.WriteAsync(bytes, 0, bytes.Length);
203	}
204	}
205	}