kdterminal.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_SIZE

Macros
#define	KEY_BS   8
#define	KEY_ESC   27
#define	KEY_DEL   127
#define	KEY_SCAN_UP   72
#define	KEY_SCAN_DOWN   80
#define	KEYSC_END   0x004f
#define	KEYSC_PAGEUP   0x0049
#define	KEYSC_PAGEDOWN   0x0051
#define	KEYSC_HOME   0x0047
#define	KEYSC_ARROWUP   0x0048

Typedefs
typedef struct _SIZE	SIZE
typedef struct _SIZE *	PSIZE
typedef enum _KDB_OUTPUT_SETTINGS	KDB_OUTPUT_SETTINGS

Enumerations
enum	_KDB_OUTPUT_SETTINGS { KD_DEBUG_KDSERIAL = 1 , KD_DEBUG_KDNOECHO = 2 }

Functions
BOOLEAN	KdpInitTerminal (VOID)
	Initializes the controlling terminal.
BOOLEAN	KdpUpdateTerminalSize (_Out_ PSIZE TermSize)
VOID	KdpFlushTerminalInput (VOID)
	Flushes terminal input (either serial or PS/2).
CHAR	KdpReadTermKey (_Out_ PULONG ScanCode)
	Reads one character from the terminal. This function returns a scan code even when reading is done from a serial terminal.

Variables
ULONG	KdbDebugState
SIZE	KdTermSize
BOOLEAN	KdTermConnected
BOOLEAN	KdTermSerial
BOOLEAN	KdTermReportsSize

Macro Definition Documentation

KEY_BS

#define KEY_BS   8

Definition at line 10 of file kdterminal.h.

KEY_DEL

#define KEY_DEL   127

Definition at line 12 of file kdterminal.h.

KEY_ESC

#define KEY_ESC   27

Definition at line 11 of file kdterminal.h.

KEY_SCAN_DOWN

#define KEY_SCAN_DOWN   80

Definition at line 15 of file kdterminal.h.

KEY_SCAN_UP

#define KEY_SCAN_UP   72

Definition at line 14 of file kdterminal.h.

KEYSC_ARROWUP

#define KEYSC_ARROWUP   0x0048

Definition at line 22 of file kdterminal.h.

KEYSC_END

#define KEYSC_END   0x004f

Definition at line 18 of file kdterminal.h.

KEYSC_HOME

#define KEYSC_HOME   0x0047

Definition at line 21 of file kdterminal.h.

KEYSC_PAGEDOWN

#define KEYSC_PAGEDOWN   0x0051

Definition at line 20 of file kdterminal.h.

KEYSC_PAGEUP

#define KEYSC_PAGEUP   0x0049

Definition at line 19 of file kdterminal.h.

Typedef Documentation

KDB_OUTPUT_SETTINGS

typedef enum _KDB_OUTPUT_SETTINGS KDB_OUTPUT_SETTINGS

PSIZE

typedef struct _SIZE * PSIZE

SIZE

SIZE

Enumeration Type Documentation

_KDB_OUTPUT_SETTINGS

enum _KDB_OUTPUT_SETTINGS

Enumerator
KD_DEBUG_KDSERIAL
KD_DEBUG_KDNOECHO

Definition at line 34 of file kdterminal.h.

{
    KD_DEBUG_KDSERIAL = 1,
    KD_DEBUG_KDNOECHO = 2
} KDB_OUTPUT_SETTINGS;

Function Documentation

KdpFlushTerminalInput()

VOID KdpFlushTerminalInput

(

VOID

)

Flushes terminal input (either serial or PS/2).

Definition at line 197 of file kdterminal.c.

{
    KdTermNextKey = ANSI_NULL;
    if (KdbDebugState & KD_DEBUG_KDSERIAL)
    {
        while (KdbpTryGetCharSerial(1) != -1);
    }
    else
    {
        ULONG ScanCode;
        while (KdbpTryGetCharKeyboard(&ScanCode, 1) != -1);
    }
}

Referenced by KdIoReadLine(), KdpInitTerminal(), and KdpUpdateTerminalSize().

KdpInitTerminal()

BOOLEAN KdpInitTerminal

(

VOID

)

Initializes the controlling terminal.

Returns

TRUE if the controlling terminal is serial and detected as being connected, or FALSE if not.

Definition at line 51 of file kdterminal.c.

{
    /* Determine whether the controlling terminal is a serial terminal:
     * serial output is enabled *and* KDSERIAL is set (i.e. user input
     * through serial). */
    KdTermSerial =
#if 0
    // Old logic where KDSERIAL also enables serial output.
    (KdbDebugState & KD_DEBUG_KDSERIAL) ||
    (KdpDebugMode.Serial && !KdpDebugMode.Screen);
#else
    // New logic where KDSERIAL does not necessarily enable serial output.
    KdpDebugMode.Serial &&
    ((KdbDebugState & KD_DEBUG_KDSERIAL) || !KdpDebugMode.Screen);
#endif
 
    /* Flush the input buffer */
    KdpFlushTerminalInput();
 
    if (KdTermSerial)
    {
        ULONG Length;
 
        /* Enable line-wrap */
        KdbpSendCommandSerial("\x1b[?7h");
 
        /*
         * Query terminal type.
         * Historically it was done with CTRL-E ('\x05'), however nowadays
         * terminals respond to it with an empty (or a user-configurable)
         * string. Instead, use the VT52-compatible 'ESC Z' sequence or the
         * VT100-compatible 'ESC[c' one.
         */
        KdbpSendCommandSerial("\x1b[c");
        KeStallExecutionProcessor(100000);
 
        Length = 0;
        for (;;)
        {
            /* Verify we get an answer, but don't care about it */
            if (KdbpTryGetCharSerial(5000) == -1)
                break;
            ++Length;
        }
 
        /* Terminal is connected (TRUE) or not connected (FALSE) */
        KdTermConnected = (Length > 0);
    }
    else
    {
        /* Terminal is not serial, assume it's *not* connected */
        KdTermConnected = FALSE;
    }
    return KdTermConnected;
}

Referenced by KdbpPagerInternal().

KdpReadTermKey()

CHAR KdpReadTermKey

(

_Out_ PULONG

ScanCode

)

Reads one character from the terminal. This function returns a scan code even when reading is done from a serial terminal.

Definition at line 217 of file kdterminal.c.

{
    CHAR Key;
 
    *ScanCode = 0;
 
    if (KdbDebugState & KD_DEBUG_KDSERIAL)
    {
        Key = (!KdTermNextKey ? KdbpGetCharSerial() : KdTermNextKey);
        KdTermNextKey = ANSI_NULL;
        if (Key == KEY_ESC) /* ESC */
        {
            Key = KdbpGetCharSerial();
            if (Key == '[')
            {
                Key = KdbpGetCharSerial();
                switch (Key)
                {
                    case 'A':
                        *ScanCode = KEY_SCAN_UP;
                        break;
                    case 'B':
                        *ScanCode = KEY_SCAN_DOWN;
                        break;
                    case 'C':
                        break;
                    case 'D':
                        break;
                }
            }
        }
    }
    else
    {
        Key = (!KdTermNextKey ? KdbpGetCharKeyboard(ScanCode) : KdTermNextKey);
        KdTermNextKey = ANSI_NULL;
    }
 
    /* Check for return */
    if (Key == '\r')
    {
        /*
         * We might need to discard the next '\n' which most clients
         * should send after \r. Wait a bit to make sure we receive it.
         */
        KeStallExecutionProcessor(100000);
 
        if (KdbDebugState & KD_DEBUG_KDSERIAL)
            KdTermNextKey = KdbpTryGetCharSerial(5);
        else
            KdTermNextKey = KdbpTryGetCharKeyboard(ScanCode, 5);
 
        if (KdTermNextKey == '\n' || KdTermNextKey == -1) /* \n or no response at all */
            KdTermNextKey = ANSI_NULL;
    }
 
    return Key;
}

Referenced by KdbpPagerInternal(), and KdIoReadLine().

KdpUpdateTerminalSize()

BOOLEAN KdpUpdateTerminalSize

(

_Out_ PSIZE

TermSize

)

Definition at line 108 of file kdterminal.c.

{
    static CHAR Buffer[128];
    CHAR c;
    LONG NumberOfCols = -1; // Or initialize to TermSize->cx ??
    LONG NumberOfRows = -1; // Or initialize to TermSize->cy ??
 
    /* Retrieve the size of the controlling terminal only when it is serial */
    if (KdTermConnected && KdTermSerial && KdTermReportsSize)
    {
        /* Flush the input buffer */
        KdpFlushTerminalInput();
 
        /* Try to query the terminal size. A reply looks like "\x1b[8;24;80t" */
        KdTermReportsSize = FALSE;
        KdbpSendCommandSerial("\x1b[18t");
        KeStallExecutionProcessor(100000);
 
        c = KdbpTryGetCharSerial(5000);
        if (c == KEY_ESC)
        {
            c = KdbpTryGetCharSerial(5000);
            if (c == '[')
            {
                ULONG Length = 0;
                for (;;)
                {
                    c = KdbpTryGetCharSerial(5000);
                    if (c == -1)
                        break;
 
                    Buffer[Length++] = c;
                    if (isalpha(c) || Length >= (sizeof(Buffer) - 1))
                        break;
                }
                Buffer[Length] = ANSI_NULL;
 
                if (Buffer[0] == '8' && Buffer[1] == ';')
                {
                    SIZE_T i;
                    for (i = 2; (i < Length) && (Buffer[i] != ';'); i++);
 
                    if (Buffer[i] == ';')
                    {
                        Buffer[i++] = ANSI_NULL;
 
                        /* Number of rows is now at Buffer + 2
                         * and number of columns at Buffer + i */
                        NumberOfRows = strtoul(Buffer + 2, NULL, 0);
                        NumberOfCols = strtoul(Buffer + i, NULL, 0);
                        KdTermReportsSize = TRUE;
                    }
                }
            }
            /* Clear further characters */
            while (KdbpTryGetCharSerial(5000) != -1);
        }
    }
 
    if (NumberOfCols <= 0)
    {
        /* Set the number of columns to the default */
        if (KdpDebugMode.Screen && !KdTermSerial)
            NumberOfCols = (SCREEN_WIDTH / 8 /*BOOTCHAR_WIDTH*/);
        else
            NumberOfCols = 80;
    }
    if (NumberOfRows <= 0)
    {
        /* Set the number of rows to the default */
        if (KdpDebugMode.Screen && !KdTermSerial)
            NumberOfRows = (SCREEN_HEIGHT / (13 /*BOOTCHAR_HEIGHT*/ + 1));
        else
            NumberOfRows = 24;
    }
 
    TermSize->cx = NumberOfCols;
    TermSize->cy = NumberOfRows;
 
    // KdIoPrintf("Cols/Rows: %dx%d\n", TermSize->cx, TermSize->cy);
 
    return KdTermReportsSize;
}

Referenced by KdbpPagerInternal().

Variable Documentation

KdbDebugState

ULONG KdbDebugState

extern

Definition at line 32 of file kdterminal.c.

Referenced by KdIoReadLine(), KdpFlushTerminalInput(), KdpGetTerminalSettings(), KdpInitTerminal(), KdpReadTermKey(), and KdReceivePacket().

KdTermConnected

BOOLEAN KdTermConnected

extern

Definition at line 34 of file kdterminal.c.

Referenced by KdbpPagerInternal(), KdpInitTerminal(), and KdpUpdateTerminalSize().

KdTermReportsSize

BOOLEAN KdTermReportsSize

extern

Definition at line 36 of file kdterminal.c.

Referenced by KdpUpdateTerminalSize().

KdTermSerial

BOOLEAN KdTermSerial

extern

Definition at line 35 of file kdterminal.c.

Referenced by KdpInitTerminal(), and KdpUpdateTerminalSize().

KdTermSize

SIZE KdTermSize

extern

Definition at line 33 of file kdterminal.c.

Referenced by KdbpPagerInternal().