Functions

Functions
int	TelnetPrintf (const char *format,...)
	Custom Telnet printf function. More...
int32_t	TelnetWriteChar (char c)
	append a char to telnet write buffer More...
void	Telnet_send_option (SOCKET *tcp_server, unsigned char option, unsigned char c)
	send a Telnet option More...
int	Telnet_check_message (telnet_server_type *telnet)
	Parse user commands. More...
uint32_t	Telnet_initialize_server (user_type *user, char *hello_msg, int16_t(*InputParser)(T_ComDevice *, char), T_Handle CmdTab)
	initialize Telnet Server More...
telnet_return_type *	Telnet_server (void)
	handle Telnet Server More...

Detailed Description

Function Documentation

int TelnetPrintf	(	const char *	format,
			...
	)

Parameters

format

- format string

Returns

amount of printed characters

{
    /***************************************************************************
     locals
    ***************************************************************************/
    va_list argptr;
    int cnt = 0;

    if ( tcp_get_state (telnet.server) != TCP_ESTABLISHED ) return (0);

    /***************************************************************************
     initializes variable argument list
    ***************************************************************************/
#pragma diag_suppress 238
    va_start (argptr, format);
#pragma diag_default  238

    /***************************************************************************
     print to buffer
    ***************************************************************************/
    cnt = vsprintf (&telnet.outbuffer[telnet.out_wptr], format, argptr);

    /***************************************************************************
     vsprintf returns the amount of printed characters. The user buffer size is
     limited to TELNET_OUTPUT_BUFFER_SIZE. Check for buffer overflow and exit if
     necessary.
    ***************************************************************************/
    telnet.out_wptr+=cnt;
    if (telnet.out_wptr > TELNET_OUTPUT_BUFFER_SIZE)
    {
        exit_code = BUFFEROVERFLOW_ERROR;
        prg_exit ("buffer overflow");
    }

    /***************************************************************************
     end variable argument list
    ***************************************************************************/
    va_end(argptr);

    return (cnt);
}

int32_t TelnetWriteChar

(

char

c

)

Parameters

c	- character to send

Returns

amount of printed characters

{
    int32_t cnt = 0;

    /***************************************************************************
     print only if connection established
    ***************************************************************************/
    if ( tcp_get_state (telnet.server) != TCP_ESTABLISHED ) return (0);

    /***************************************************************************
     print to buffer
    ***************************************************************************/
    cnt = 1;
    telnet.outbuffer[telnet.out_wptr] = c;

    /***************************************************************************
     The user buffer size is limited to TELNET_OUTPUT_BUFFER_SIZE. Check for
     buffer overflow and exit if necessary.
    ***************************************************************************/
    telnet.out_wptr+=cnt;
    telnet.outbuffer[telnet.out_wptr] = 0;
    if (telnet.out_wptr > TELNET_OUTPUT_BUFFER_SIZE)
    {
        exit_code = BUFFEROVERFLOW_ERROR;
        prg_exit ("buffer overflow");
    }

    return (cnt);
}

void Telnet_send_option	(	SOCKET *	tcp_server,
		unsigned char	option,
		unsigned char	c
	)

Parameters

tcp_server	- current connection
option	- option to send
c	- option value

Returns

nothing

See also

net_send_ready() - netlib

{
    /***************************************************************************
     locals
    ***************************************************************************/

    telnet_option_msg[1] = option;
    telnet_option_msg[2] = c;
    net_send_ready (tcp_server, telnet_option_msg, 4L, 100000);
}

int Telnet_check_message

(

telnet_server_type *

telnet

)

Parameters

telnet

- connected TCP server socket

Returns

• ( 0) Normal return
• (>0) After successful up/download or error

{
    /***************************************************************************
     locals
    ***************************************************************************/
    int len=0;                         /* receive length                      */
    char c;
    char *cp;
    int16_t ret = 0;
    tpInputParser InputParser =
#ifdef INC_CMD
            (tpInputParser)(int32_t)CMD_process_user_input;
#else
            (tpInputParser)(int32_t)telnet->CmdDevice.InputParser;
#endif

    /***************************************************************************
     new message received ?
    ***************************************************************************/
    if (net_recv (telnet-> server, telnet-> inbuffer, TCP_MAX_PACKET_SIZE))
    {
        len = net_recv_event_handler (telnet-> server, NULL);
    }
    if (len)
    {
        /***********************************************************************
         parse buffer
        ***********************************************************************/
        cp = telnet-> inbuffer;
        while ( len )
        {
            /*******************************************************************
             get one character
            *******************************************************************/
            c = *cp++;  len--;

            /*******************************************************************
             parse telnet protocol
            *******************************************************************/
            switch ( telnet-> state )
            {
                case TSTATE_NORMAL:
                    if ((unsigned char)c == TELNET_IAC)
                    {
                        telnet-> state = TSTATE_IAC;
                    }
                    else
                    {
                        /*******************************************************
                         process user command
                        *******************************************************/
                        switch ((unsigned char)c)
                        {
                            case TELNET_IAC :
                            case TELNET_WILL:
                            case TELNET_WONT:
                            case TELNET_DO  :
                            case TELNET_DONT:
                                /***********************************************
                                 ignore telnet control characters
                                ***********************************************/
                                break;

                            default:
                                /***********************************************
                                 parse character
                                ***********************************************/
                                ret = InputParser (&telnet->CmdDevice, c);
                                if (ret)
                                {
                                    len = 0;
                                }
                                break;
                        }
                    }
                    break;

                case TSTATE_IAC:
                    if ((unsigned char)c == TELNET_IAC)
                    {
                        /*******************************************************
                         not valid, back to normal state
                        *******************************************************/
                        telnet-> state = TSTATE_NORMAL;
                    }
                    else
                    {
                        /*******************************************************
                         telnet option
                        *******************************************************/
                        switch ((unsigned char)c)
                        {
                            case TELNET_WILL:
                                telnet-> state = TSTATE_WILL;
                                break;

                            case TELNET_WONT:
                                telnet-> state = TSTATE_WONT;
                                break;

                            case TELNET_DO:
                                telnet-> state = TSTATE_DO;
                                break;

                            case TELNET_DONT:
                                telnet-> state = TSTATE_DONT;
                                break;

                            default:
                                telnet-> state = TSTATE_NORMAL;
                                break;
                        }
                    }
                    break;

                case TSTATE_WILL:
                    /***********************************************************
                     Reply with a DONT
                    ***********************************************************/
                    Telnet_send_option (telnet-> server, TELNET_DONT, c);
                    telnet-> state = TSTATE_NORMAL;
                    break;

                case TSTATE_WONT:
                    /***********************************************************
                     Reply with a DONT
                    ***********************************************************/
                    Telnet_send_option (telnet-> server, TELNET_DONT, c);
                    telnet-> state = TSTATE_NORMAL;
                    break;

                case TSTATE_DO:
                    /***********************************************************
                     Reply with a WONT
                    ***********************************************************/
                    Telnet_send_option (telnet-> server, TELNET_WONT, c);
                    telnet-> state = TSTATE_NORMAL;
                    break;

                case TSTATE_DONT:
                    /***********************************************************
                     Reply with a WONT
                    ***********************************************************/
                    Telnet_send_option (telnet-> server, TELNET_WONT, c);
                    telnet-> state = TSTATE_NORMAL;
                    break;

                default :
                    telnet-> state = TSTATE_NORMAL;
                    break;
            } // switch
        } // while
    }

    return ((int)ret);
}

uint32_t Telnet_initialize_server	(	user_type *	user,
		char *	hello_msg,
		int16_t(*)(T_ComDevice *, char)	InputParser,
		T_Handle	CmdTab
	)

Parameters

*user	- pointer to user list
*hello_msg	- user defined welcome message
*InputParser	- input parser
CmdTab	- command table

Returns

• TRUE - success
• FALSE - error

{
    /***************************************************************************
     locals
    ***************************************************************************/
    /* - */

    /***************************************************************************
     initialize Telnet server
    ***************************************************************************/
    telnet.so_state = TELNET_SOCKET_DISCONNECTED;
    telnet.state = TSTATE_NORMAL;
    telnet.out_wptr = 0;
    telnet.hello_msg = hello_msg;
    // telnet_user_list = user;
    (void)user;

    /***************************************************************************
     create TCP data server socket on telnet port
    ***************************************************************************/
    telnet.server = socket_open (ANY_ADDRESS,
                                 ANY_PORT,
                                 TELNET_PORT,
                                 DATATYPE_CHAR,
                                 TCP_INIT_FUNC);
    if ( telnet.server == INVALID_SOCKET )
    {
        return (FALSE);
    }

    /***************************************************************************
     set receive-buffer size
    ***************************************************************************/
    set_recv_buffer (telnet.server, telnet.inbuffer, TCP_MAX_PACKET_SIZE);

    /***************************************************************************
     configure command processor
    ***************************************************************************/
    telnet.CmdDevice.out = TelnetWriteChar;
    telnet.CmdDevice.outs = TelnetWriteStr;
    telnet.CmdDevice.outf = TelnetPrintf;
    telnet.CmdDevice.gp = (T_Handle)&telnet;
    telnet.CmdDevice.dev = COM_DEV_TELNET;
    telnet.CmdDevice.aCmdLine =
#ifdef INC_CMD
           aTelnetCmdLine;
#else
           NULL;
#endif
    telnet.CmdDevice.InputParser = (T_Handle)InputParser;
    telnet.CmdDevice.CmdTab = CmdTab;

    return (TRUE);
}

telnet_return_type* Telnet_server

(

void

)

Returns

• ( 0) Normal return
• (>0) After successful up/download or error

See also

tcp_get_state() - netlib

net_send_string() - netlib

telnet_check_message() - this module

{
    /***************************************************************************
     locals
    ***************************************************************************/
    telnet_return_type *telnet_ret = NULL;
    static timeval OutScanTime;

    /***************************************************************************
     check for connection established
    ***************************************************************************/
    if ( tcp_get_state (telnet.server) == TCP_ESTABLISHED )
    {
        /***********************************************************************
         is it a new connection ?
        ***********************************************************************/
        if ( telnet.so_state == TELNET_SOCKET_DISCONNECTED )
        {
            /*******************************************************************
             clear the SO_CONNECTION_ESTABLISHED event
            *******************************************************************/
            telnet.server-> error_code = SO_NO_ERROR;

            /*******************************************************************
             print a hello message
            *******************************************************************/
            if (telnet.hello_msg)
            {
                TelnetWriteStr ( telnet.hello_msg);
                TelnetWriteStr ("\r\n");
            }

            telnet_active = telnet.so_state = TELNET_SOCKET_CONNECTED;

            /*******************************************************************
             set detailed return parameter
            *******************************************************************/
            telnet.telnet_ret.offset = telnet.server-> dest_addr;
            telnet.telnet_ret.reason = TELNET_NEW_CON;
            telnet_ret = &(telnet.telnet_ret);
        }

        /***********************************************************************
         check for new message
        ***********************************************************************/
        if (Telnet_check_message (&telnet))
        {
            /*******************************************************************
             set detailed return parameter
            *******************************************************************/
            telnet_ret = &(telnet.telnet_ret);
        }

        /***********************************************************************
         check for data to send
        ***********************************************************************/
        if (telnet.out_wptr)
        {
            if ( tv_elapsed (&OutScanTime, UINT32_C(0), TELNET_OUTPUT_SCAN_INTERVAL, TRUE) )
            {
                net_send_safe (telnet.server,
                               telnet.outbuffer,
                               telnet.out_wptr,
                               TCP_NOWAIT);
                telnet.out_wptr=0;
            }
        }
    }
    else
    {
        /***********************************************************************
         if server is listening
        ***********************************************************************/
        if ( tcp_get_state (telnet.server) == TCP_LISTEN )
        {
            /*******************************************************************
             but status connected
            *******************************************************************/
            if ( telnet.so_state == TELNET_SOCKET_CONNECTED)
            {
                /***************************************************************
                 clear status
                ***************************************************************/
                telnet_active = telnet.so_state = TELNET_SOCKET_DISCONNECTED;

                /***************************************************************
                 set detailed return parameter
                ***************************************************************/
                telnet.telnet_ret.reason = TELNET_CLOSE_CON;
                telnet_ret = &(telnet.telnet_ret);
            }
        }
    }
    return (telnet_ret);
}