Microchip%20TCP_IP%20stack/TCPIP%20Stack/Telnet.c

/*********************************************************************
 *
 *      Telnet Server
 *  Module for Microchip TCP/IP Stack
 *       -Provides Telnet services on TCP port 23
 *       -Reference: RFC 854
 *
 *********************************************************************
 * FileName:        Telnet.c
 * Dependencies:    TCP.h
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30, dsPIC33F
 * Complier:        Microchip C18 v3.03 or higher
 *                                      Microchip C30 v2.02 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright © 2002-2007 Microchip Technology Inc.  All rights 
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and 
 * distribute: 
 * (i)  the Software when embedded on a Microchip microcontroller or 
 *      digital signal controller product (“Device”) which is 
 *      integrated into Licensee’s product; or
 * (ii) ONLY the Software driver source files ENC28J60.c and 
 *      ENC28J60.h ported to a non-Microchip device used in 
 *      conjunction with a Microchip ethernet controller for the 
 *      sole purpose of interfacing with the ethernet controller. 
 *
 * You should refer to the license agreement accompanying this 
 * Software for additional information regarding your rights and 
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT 
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT 
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF 
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS 
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE 
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER 
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT 
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date    Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Howard Schlunder     9/12/06 Original
 ********************************************************************/
#define __TELNET_C

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_TELNET_SERVER)

#if TCP_TX_FIFO_SIZE < 100
        #error  Error, the Telnet module requires at least a TX FIFO size of 100 bytes.  Increase TCP_TX_FIFO_SIZE.
#endif


#define TELNET_PORT     23

#define USERNAME                "telnet"
#define PASSWORD                "microchip"


static ROM BYTE strTitle[]                      = "\x1b[2J\x1b[31m\x1b[1m"      // 2J is clear screen, 31m is red, 1m is bold
                                                                          "Microchip Telnet Server 1.1\x1b[0m\r\n"      // 0m is clear all attributes
                                                                          "(for this demo, type 'telnet' for the login and 'microchip' for the password.)\r\n"
                                                                          "Login: ";
static ROM BYTE strPassword[]           = "Password: \xff\xfd\x2d";     // DO Suppress Local Echo (stop telnet client from printing typed characters)
static ROM BYTE strAccessDenied[]       = "\r\nAccess denied\r\n\r\n";
static ROM BYTE strAuthenticated[]      = "\r\nLogged in successfully\r\n\r\n"
                                                                          "\r\nPress 'q' to quit\r\n";
static ROM BYTE strDisplay[]            = "\r\nAnalog:             1023"
                                                                          "\r\nButtons:         3 2 1 0"
                                                                          "\r\nLEDs:    7 6 5 4 3 2 1 0";
static ROM BYTE strGoodBye[]            = "\r\n\r\nGoodbye!\r\n";

extern BYTE AN0String[8];

/*********************************************************************
 * Function:        void TelnetTask(void)
 *
 * PreCondition:    Stack is initialized()
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            None
 ********************************************************************/
void TelnetTask(void)
{
        BYTE                            i;
        WORD                            w, w2;
        static TCP_SOCKET       MySocket = INVALID_SOCKET;
        static enum _TelnetState
        {
                SM_HOME = 0,
                SM_PRINT_LOGIN,
                SM_GET_LOGIN,
                SM_GET_PASSWORD,
                SM_GET_PASSWORD_BAD_LOGIN,
                SM_AUTHENTICATED,
                SM_REFRESH_VALUES,
        }                                       TelnetState = SM_HOME;

        // Reset our state if the remote client disconnected from us
        if(TelnetState >= SM_PRINT_LOGIN)
        {
                if(!TCPIsConnected(MySocket))
                {
                        TelnetState = SM_PRINT_LOGIN;
                        return;
                }
        }

        switch(TelnetState)
        {
                case SM_HOME:
                        // Connect a socket to the remote TCP server
                        MySocket = TCPListen(TELNET_PORT);
                        
                        // Abort operation if no TCP sockets are available
                        // If this ever happens, incrementing MAX_TCP_SOCKETS in 
                        // StackTsk.h may help (at the expense of more global memory 
                        // resources).
                        if(MySocket == INVALID_SOCKET)
                                break;

                        TelnetState++;
                        break;

                case SM_PRINT_LOGIN:
                        // Make certain the socket can be written to
                        if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strTitle))
                                break;
                        
                        // Place the application protocol data into the transmit buffer.
                        TCPPutROMString(MySocket, strTitle);

                        // Send the packet
                        TCPFlush(MySocket);
                        TelnetState++;

                case SM_GET_LOGIN:
                        // Make sure we can put the password prompt
                        if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strPassword))
                                break;

                        // See if the user pressed return
                        w = TCPFind(MySocket, '\n', 0, FALSE);
                        if(w == 0xFFFFu)
                        {
                                if(TCPGetRxFIFOFree(MySocket) == 0u)
                                {
                                        TCPPutROMString(MySocket, (ROM BYTE*)"Too much data.\r\n");
                                        TCPDisconnect(MySocket);
                                }

                                break;
                        }
                
                        // Search for the username -- case insensitive
                        w2 = TCPFindROMArray(MySocket, (ROM BYTE*)USERNAME, sizeof(USERNAME)-1, 0, TRUE);
                        if((w2 != 0) || !((sizeof(USERNAME)-1 == w) || (sizeof(USERNAME) == w)))
                        {
                                // Did not find the username, but let's pretend we did so we don't leak the user name validity
                                TelnetState = SM_GET_PASSWORD_BAD_LOGIN;        
                        }
                        else
                        {
                                TelnetState = SM_GET_PASSWORD;
                        }

                        // Username verified, throw this line of data away
                        TCPGetArray(MySocket, NULL, w + 1);

                        // Print the password prompt
                        TCPPutROMString(MySocket, strPassword);
                        TCPFlush(MySocket);
                        break;

                case SM_GET_PASSWORD:
                case SM_GET_PASSWORD_BAD_LOGIN:
                        // Make sure we can put the authenticated prompt
                        if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strAuthenticated))
                                break;

                        // See if the user pressed return
                        w = TCPFind(MySocket, '\n', 0, FALSE);
                        if(w == 0xFFFFu)
                        {
                                if(TCPGetRxFIFOFree(MySocket) == 0u)
                                {
                                        TCPPutROMString(MySocket, (ROM BYTE*)"Too much data.\r\n");
                                        TCPDisconnect(MySocket);
                                }

                                break;
                        }

                        // Search for the password -- case sensitive
                        w2 = TCPFindROMArray(MySocket, (ROM BYTE*)PASSWORD, sizeof(PASSWORD)-1, 0, FALSE);
                        if((w2 != 3) || !((sizeof(PASSWORD)-1 == w-3) || (sizeof(PASSWORD) == w-3)) || (TelnetState == SM_GET_PASSWORD_BAD_LOGIN))
                        {
                                // Did not find the password
                                TelnetState = SM_PRINT_LOGIN;   
                                TCPPutROMString(MySocket, strAccessDenied);
                                TCPDisconnect(MySocket);
                                break;
                        }

                        // Password verified, throw this line of data away
                        TCPGetArray(MySocket, NULL, w + 1);

                        // Print the authenticated prompt
                        TCPPutROMString(MySocket, strAuthenticated);
                        TelnetState = SM_AUTHENTICATED;
                        // No break
        
                case SM_AUTHENTICATED:
                        if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strDisplay) + 4)
                                break;

                        TCPPutROMString(MySocket, strDisplay);
                        TelnetState++;

                        // All future characters will be bold
                        TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[1m");

                case SM_REFRESH_VALUES:
                        if(TCPIsPutReady(MySocket) >= 60u)
                        {
                                //[10;1]
                                //"Analog:             1023\r\n"
                                //"Buttons:         3 2 1 0\r\n"
                                //"LEDs:    7 6 5 4 3 2 1 0\r\n"
        
                                // Position cursor at Line 10, Col 21
                                TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[10;21f");

                                // Put analog value with space padding on right side for 4 characters
                                TCPPutROMArray(MySocket, (ROM BYTE*)"    ", 4-strlen((char*)AN0String));
                                TCPPutString(MySocket, AN0String);

                                // Put Buttons
                                TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[11;18f");
                                TCPPut(MySocket, BUTTON3_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, BUTTON2_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, BUTTON1_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, BUTTON0_IO ? '1':'0');
        
        
                                // Put LEDs
                                TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[12;10f");
                                TCPPut(MySocket, LED7_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, LED6_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, LED5_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, LED4_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, LED3_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, LED2_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, LED1_IO ? '1':'0');
                                TCPPut(MySocket, ' ');
                                TCPPut(MySocket, LED0_IO ? '1':'0');
        
        
                                // Put cursor at beginning of next line
                                TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[13;1f");

                                // Send the data out immediately
                                TCPFlush(MySocket);
                        }

                        if(TCPIsGetReady(MySocket))
                        {
                                TCPGet(MySocket, &i);
                                switch(i)
                                {
                                        case '\r':
                                        case 'q':
                                        case 'Q':
                                                if(TCPIsPutReady(MySocket) >= strlenpgm((ROM char*)strGoodBye))
                                                        TCPPutROMString(MySocket, strGoodBye);
                                                TCPDisconnect(MySocket);
                                                TelnetState = SM_PRINT_LOGIN;                                                   
                                                break;
                                }
                        }

                        break;
        }
}

#endif  //#if defined(STACK_USE_TELNET_SERVER)
1	/*********************************************************************
2	*
3	* Telnet Server
4	* Module for Microchip TCP/IP Stack
5	* -Provides Telnet services on TCP port 23
6	* -Reference: RFC 854
7	*
8	*********************************************************************
9	* FileName: Telnet.c
10	* Dependencies: TCP.h
11	* Processor: PIC18, PIC24F, PIC24H, dsPIC30, dsPIC33F
12	* Complier: Microchip C18 v3.03 or higher
13	* Microchip C30 v2.02 or higher
14	* Company: Microchip Technology, Inc.
15	*
16	* Software License Agreement
17	*
18	* Copyright © 2002-2007 Microchip Technology Inc. All rights
19	* reserved.
20	*
21	* Microchip licenses to you the right to use, modify, copy, and
22	* distribute:
23	* (i) the Software when embedded on a Microchip microcontroller or
24	* digital signal controller product (“Device”) which is
25	* integrated into Licensee’s product; or
26	* (ii) ONLY the Software driver source files ENC28J60.c and
27	* ENC28J60.h ported to a non-Microchip device used in
28	* conjunction with a Microchip ethernet controller for the
29	* sole purpose of interfacing with the ethernet controller.
30	*
31	* You should refer to the license agreement accompanying this
32	* Software for additional information regarding your rights and
33	* obligations.
34	*
35	* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
36	* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
37	* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
38	* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
39	* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
40	* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
41	* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
42	* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
43	* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
44	* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
45	* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
46	*
47	*
48	* Author Date Comment
49	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
50	* Howard Schlunder 9/12/06 Original
51	********************************************************************/
52	#define __TELNET_C
53
54	#include "TCPIP Stack/TCPIP.h"
55
56	#if defined(STACK_USE_TELNET_SERVER)
57
58	#if TCP_TX_FIFO_SIZE < 100
59	#error Error, the Telnet module requires at least a TX FIFO size of 100 bytes. Increase TCP_TX_FIFO_SIZE.
60	#endif
61
62
63	#define TELNET_PORT 23
64
65	#define USERNAME "telnet"
66	#define PASSWORD "microchip"
67
68
69	static ROM BYTE strTitle[] = "\x1b[2J\x1b[31m\x1b[1m" // 2J is clear screen, 31m is red, 1m is bold
70	"Microchip Telnet Server 1.1\x1b[0m\r\n" // 0m is clear all attributes
71	"(for this demo, type 'telnet' for the login and 'microchip' for the password.)\r\n"
72	"Login: ";
73	static ROM BYTE strPassword[] = "Password: \xff\xfd\x2d"; // DO Suppress Local Echo (stop telnet client from printing typed characters)
74	static ROM BYTE strAccessDenied[] = "\r\nAccess denied\r\n\r\n";
75	static ROM BYTE strAuthenticated[] = "\r\nLogged in successfully\r\n\r\n"
76	"\r\nPress 'q' to quit\r\n";
77	static ROM BYTE strDisplay[] = "\r\nAnalog: 1023"
78	"\r\nButtons: 3 2 1 0"
79	"\r\nLEDs: 7 6 5 4 3 2 1 0";
80	static ROM BYTE strGoodBye[] = "\r\n\r\nGoodbye!\r\n";
81
82	extern BYTE AN0String[8];
83
84	/*********************************************************************
85	* Function: void TelnetTask(void)
86	*
87	* PreCondition: Stack is initialized()
88	*
89	* Input: None
90	*
91	* Output: None
92	*
93	* Side Effects: None
94	*
95	* Overview: None
96	*
97	* Note: None
98	********************************************************************/
99	void TelnetTask(void)
100	{
101	BYTE i;
102	WORD w, w2;
103	static TCP_SOCKET MySocket = INVALID_SOCKET;
104	static enum _TelnetState
105	{
106	SM_HOME = 0,
107	SM_PRINT_LOGIN,
108	SM_GET_LOGIN,
109	SM_GET_PASSWORD,
110	SM_GET_PASSWORD_BAD_LOGIN,
111	SM_AUTHENTICATED,
112	SM_REFRESH_VALUES,
113	} TelnetState = SM_HOME;
114
115	// Reset our state if the remote client disconnected from us
116	if(TelnetState >= SM_PRINT_LOGIN)
117	{
118	if(!TCPIsConnected(MySocket))
119	{
120	TelnetState = SM_PRINT_LOGIN;
121	return;
122	}
123	}
124
125	switch(TelnetState)
126	{
127	case SM_HOME:
128	// Connect a socket to the remote TCP server
129	MySocket = TCPListen(TELNET_PORT);
130
131	// Abort operation if no TCP sockets are available
132	// If this ever happens, incrementing MAX_TCP_SOCKETS in
133	// StackTsk.h may help (at the expense of more global memory
134	// resources).
135	if(MySocket == INVALID_SOCKET)
136	break;
137
138	TelnetState++;
139	break;
140
141	case SM_PRINT_LOGIN:
142	// Make certain the socket can be written to
143	if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strTitle))
144	break;
145
146	// Place the application protocol data into the transmit buffer.
147	TCPPutROMString(MySocket, strTitle);
148
149	// Send the packet
150	TCPFlush(MySocket);
151	TelnetState++;
152
153	case SM_GET_LOGIN:
154	// Make sure we can put the password prompt
155	if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strPassword))
156	break;
157
158	// See if the user pressed return
159	w = TCPFind(MySocket, '\n', 0, FALSE);
160	if(w == 0xFFFFu)
161	{
162	if(TCPGetRxFIFOFree(MySocket) == 0u)
163	{
164	TCPPutROMString(MySocket, (ROM BYTE*)"Too much data.\r\n");
165	TCPDisconnect(MySocket);
166	}
167
168	break;
169	}
170
171	// Search for the username -- case insensitive
172	w2 = TCPFindROMArray(MySocket, (ROM BYTE*)USERNAME, sizeof(USERNAME)-1, 0, TRUE);
173	if((w2 != 0) \|\| !((sizeof(USERNAME)-1 == w) \|\| (sizeof(USERNAME) == w)))
174	{
175	// Did not find the username, but let's pretend we did so we don't leak the user name validity
176	TelnetState = SM_GET_PASSWORD_BAD_LOGIN;
177	}
178	else
179	{
180	TelnetState = SM_GET_PASSWORD;
181	}
182
183	// Username verified, throw this line of data away
184	TCPGetArray(MySocket, NULL, w + 1);
185
186	// Print the password prompt
187	TCPPutROMString(MySocket, strPassword);
188	TCPFlush(MySocket);
189	break;
190
191	case SM_GET_PASSWORD:
192	case SM_GET_PASSWORD_BAD_LOGIN:
193	// Make sure we can put the authenticated prompt
194	if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strAuthenticated))
195	break;
196
197	// See if the user pressed return
198	w = TCPFind(MySocket, '\n', 0, FALSE);
199	if(w == 0xFFFFu)
200	{
201	if(TCPGetRxFIFOFree(MySocket) == 0u)
202	{
203	TCPPutROMString(MySocket, (ROM BYTE*)"Too much data.\r\n");
204	TCPDisconnect(MySocket);
205	}
206
207	break;
208	}
209
210	// Search for the password -- case sensitive
211	w2 = TCPFindROMArray(MySocket, (ROM BYTE*)PASSWORD, sizeof(PASSWORD)-1, 0, FALSE);
212	if((w2 != 3) \|\| !((sizeof(PASSWORD)-1 == w-3) \|\| (sizeof(PASSWORD) == w-3)) \|\| (TelnetState == SM_GET_PASSWORD_BAD_LOGIN))
213	{
214	// Did not find the password
215	TelnetState = SM_PRINT_LOGIN;
216	TCPPutROMString(MySocket, strAccessDenied);
217	TCPDisconnect(MySocket);
218	break;
219	}
220
221	// Password verified, throw this line of data away
222	TCPGetArray(MySocket, NULL, w + 1);
223
224	// Print the authenticated prompt
225	TCPPutROMString(MySocket, strAuthenticated);
226	TelnetState = SM_AUTHENTICATED;
227	// No break
228
229	case SM_AUTHENTICATED:
230	if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strDisplay) + 4)
231	break;
232
233	TCPPutROMString(MySocket, strDisplay);
234	TelnetState++;
235
236	// All future characters will be bold
237	TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[1m");
238
239	case SM_REFRESH_VALUES:
240	if(TCPIsPutReady(MySocket) >= 60u)
241	{
242	//[10;1]
243	//"Analog: 1023\r\n"
244	//"Buttons: 3 2 1 0\r\n"
245	//"LEDs: 7 6 5 4 3 2 1 0\r\n"
246
247	// Position cursor at Line 10, Col 21
248	TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[10;21f");
249
250	// Put analog value with space padding on right side for 4 characters
251	TCPPutROMArray(MySocket, (ROM BYTE)" ", 4-strlen((char)AN0String));
252	TCPPutString(MySocket, AN0String);
253
254	// Put Buttons
255	TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[11;18f");
256	TCPPut(MySocket, BUTTON3_IO ? '1':'0');
257	TCPPut(MySocket, ' ');
258	TCPPut(MySocket, BUTTON2_IO ? '1':'0');
259	TCPPut(MySocket, ' ');
260	TCPPut(MySocket, BUTTON1_IO ? '1':'0');
261	TCPPut(MySocket, ' ');
262	TCPPut(MySocket, BUTTON0_IO ? '1':'0');
263
264
265	// Put LEDs
266	TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[12;10f");
267	TCPPut(MySocket, LED7_IO ? '1':'0');
268	TCPPut(MySocket, ' ');
269	TCPPut(MySocket, LED6_IO ? '1':'0');
270	TCPPut(MySocket, ' ');
271	TCPPut(MySocket, LED5_IO ? '1':'0');
272	TCPPut(MySocket, ' ');
273	TCPPut(MySocket, LED4_IO ? '1':'0');
274	TCPPut(MySocket, ' ');
275	TCPPut(MySocket, LED3_IO ? '1':'0');
276	TCPPut(MySocket, ' ');
277	TCPPut(MySocket, LED2_IO ? '1':'0');
278	TCPPut(MySocket, ' ');
279	TCPPut(MySocket, LED1_IO ? '1':'0');
280	TCPPut(MySocket, ' ');
281	TCPPut(MySocket, LED0_IO ? '1':'0');
282
283
284	// Put cursor at beginning of next line
285	TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[13;1f");
286
287	// Send the data out immediately
288	TCPFlush(MySocket);
289	}
290
291	if(TCPIsGetReady(MySocket))
292	{
293	TCPGet(MySocket, &i);
294	switch(i)
295	{
296	case '\r':
297	case 'q':
298	case 'Q':
299	if(TCPIsPutReady(MySocket) >= strlenpgm((ROM char*)strGoodBye))
300	TCPPutROMString(MySocket, strGoodBye);
301	TCPDisconnect(MySocket);
302	TelnetState = SM_PRINT_LOGIN;
303	break;
304	}
305	}
306
307	break;
308	}
309	}
310
311	#endif //#if defined(STACK_USE_TELNET_SERVER)