mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2366 lines
78 KiB
2366 lines
78 KiB
//Copyright (c) Microsoft Corporation. All rights reserved.
|
|
/****************************************************************************
|
|
|
|
PROGRAM: WinTel.c
|
|
|
|
PURPOSE: WinTel template for Windows applications
|
|
|
|
FUNCTIONS:
|
|
|
|
main() - calls initialization function, processes message loop
|
|
InitApplication() - initializes window data and registers window
|
|
InitInstance() - saves instance handle and creates main window
|
|
MainWndProc() - processes messages
|
|
About() - processes messages for "About" dialog box
|
|
|
|
COMMENTS:
|
|
|
|
Windows can have several copies of your application running at the
|
|
same time. The variable hInst keeps track of which instance this
|
|
application is so that processing will be to the correct window.
|
|
|
|
TABS:
|
|
|
|
Set for 4 spaces.
|
|
|
|
****************************************************************************/
|
|
|
|
#include <windows.h> // required for all Windows applications
|
|
#include <tchar.h> // required for all Windows applications
|
|
#pragma warning (disable: 4201) // disable "nonstandard extension used : nameless struct/union"
|
|
#include <commdlg.h>
|
|
#pragma warning (default: 4201)
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <lmcons.h>
|
|
#include <winbase.h>
|
|
|
|
#include "urlmon.h"
|
|
#include "zone.h"
|
|
|
|
|
|
#ifdef WHISTLER_BUILD
|
|
#include <ntverp.h>
|
|
#else
|
|
#include "solarver.h"
|
|
#endif
|
|
#include <common.ver>
|
|
|
|
#pragma warning( disable:4706 )
|
|
#pragma warning(disable:4100)
|
|
|
|
#include <imm.h>
|
|
#include <locale.h>
|
|
|
|
#include "WinTel.h" // specific to this program
|
|
#include "debug.h"
|
|
#include "trmio.h"
|
|
|
|
#ifndef NO_PCHECK
|
|
#ifndef WHISTLER_BUILD
|
|
#include "piracycheck.h"
|
|
#endif
|
|
#endif
|
|
|
|
#include "commands.h"
|
|
#include "LocResMan.h"
|
|
|
|
|
|
#define MAX_USAGE_LEN 1400
|
|
TCHAR szUsage[MAX_USAGE_LEN];
|
|
|
|
#if 0
|
|
OPENFILENAME ofn;
|
|
TCHAR buffer[256];
|
|
#endif
|
|
|
|
HANDLE g_hCaptureConsoleEvent = NULL;
|
|
|
|
HINSTANCE ghInstance;
|
|
WI gwi;
|
|
|
|
HANDLE g_hAsyncGetHostByNameEvent = NULL;
|
|
HANDLE g_hControlHandlerEvent = NULL;
|
|
HANDLE g_hTelnetPromptConsoleBuffer = NULL;
|
|
HANDLE g_hSessionConsoleBuffer = NULL;
|
|
|
|
/* This event synchronizes the output to g_hTelnetPromptConsoleBuffer
|
|
and g_hSessionConsoleBuffer. It prevents session data coming at the prompt
|
|
and viceversa - BUG 2176*/
|
|
|
|
HANDLE g_hRemoteNEscapeModeDataSync = NULL;
|
|
|
|
TCHAR g_szKbdEscape[ SMALL_STRING + 1 ];
|
|
BOOL g_bIsEscapeCharValid = TRUE;
|
|
|
|
DWORD HandleTelnetSession(WI *pwi);
|
|
BOOL StuffEscapeIACs( PUCHAR* ppBufDest, UCHAR bufSrc[], DWORD* pdwSize );
|
|
BOOL fPrintMessageToSessionConsole = FALSE;
|
|
BOOL fClientLaunchedFromCommandPrompt = FALSE;
|
|
BOOL g_fConnectFailed = 0;
|
|
|
|
void ConvertAndSendVTNTData( LPTSTR pData, int iLen );
|
|
|
|
extern BOOL bDoVtNTFirstTime;
|
|
|
|
HIMC hImeContext;
|
|
extern VOID SetImeWindow(TRM *ptrm);
|
|
extern void WriteMessage( DWORD dwMsgId, WCHAR szEnglishString[] );
|
|
|
|
DWORD CurrentKanjiSelection = 0;
|
|
KANJILIST KanjiList[NUMBER_OF_KANJI] =
|
|
{
|
|
/* KanjiID, KanjiEmulationID, KanjiMessageID, KanjiItemID */
|
|
{ fdwSJISKanjiMode, dwSJISKanji, IDS_KANJI_SJIS, 0, L"\0" },
|
|
{ fdwJISKanjiMode, dwJISKanji, IDS_KANJI_JIS, 0, L"\0" },
|
|
{ fdwJIS78KanjiMode,dwJIS78Kanji, IDS_KANJI_JIS78,0, L"\0" },
|
|
{ fdwEUCKanjiMode, dwEUCKanji, IDS_KANJI_EUC, 0, L"\0" },
|
|
{ fdwNECKanjiMode, dwNECKanji, IDS_KANJI_NEC, 0, L"\0" },
|
|
{ fdwDECKanjiMode, dwDECKanji, IDS_KANJI_DEC, 0, L"\0" },
|
|
{ fdwACOSKanjiMode, dwACOSKanji, IDS_KANJI_ACOS, 0, L"\0" }
|
|
};
|
|
BOOL fHSCROLL = FALSE;
|
|
TCHAR szVT100KanjiEmulation[SMALL_STRING + 1];
|
|
|
|
#define NUM_ISO8859_CHARS 3
|
|
#define NUM_WINDOWS_CP1252_CHARS 4
|
|
|
|
UINT gfCodeModeFlags[1+((eCodeModeMax-1)/N_BITS_IN_UINT)];
|
|
|
|
extern INT GetRequestedTermType( LPTSTR pszTerm );
|
|
|
|
TCHAR szUserName[ UNLEN + 1 ];
|
|
|
|
void PrintUsage()
|
|
{
|
|
DWORD dwWritten = 0;
|
|
CHAR szStr[MAX_USAGE_LEN] = { 0 };
|
|
MyWriteConsole(g_hSessionConsoleBuffer,szUsage,_tcslen(szUsage));
|
|
}
|
|
|
|
BOOL
|
|
FileIsConsole(
|
|
HANDLE fp
|
|
)
|
|
{
|
|
unsigned htype;
|
|
|
|
htype = GetFileType(fp);
|
|
htype &= ~FILE_TYPE_REMOTE;
|
|
return htype == FILE_TYPE_CHAR;
|
|
}
|
|
|
|
void
|
|
MyWriteConsole(
|
|
HANDLE fp,
|
|
LPWSTR lpBuffer,
|
|
DWORD cchBuffer
|
|
)
|
|
{
|
|
//
|
|
// Jump through hoops for output because:
|
|
//
|
|
// 1. printf() family chokes on international output (stops
|
|
// printing when it hits an unrecognized character)
|
|
//
|
|
// 2. WriteConsole() works great on international output but
|
|
// fails if the handle has been redirected (i.e., when the
|
|
// output is piped to a file)
|
|
//
|
|
// 3. WriteFile() works great when output is piped to a file
|
|
// but only knows about bytes, so Unicode characters are
|
|
// printed as two Ansi characters.
|
|
//
|
|
|
|
if (FileIsConsole(fp))
|
|
{
|
|
WriteConsole(fp, lpBuffer, cchBuffer, &cchBuffer, NULL);
|
|
}
|
|
else
|
|
{
|
|
LPSTR lpAnsiBuffer = (LPSTR) LocalAlloc(LMEM_FIXED, cchBuffer * sizeof(WCHAR));
|
|
|
|
if (lpAnsiBuffer != NULL)
|
|
{
|
|
cchBuffer = WideCharToMultiByte(CP_OEMCP,
|
|
0,
|
|
lpBuffer,
|
|
cchBuffer,
|
|
lpAnsiBuffer,
|
|
cchBuffer * sizeof(WCHAR),
|
|
NULL,
|
|
NULL);
|
|
|
|
if (cchBuffer != 0)
|
|
{
|
|
WriteFile(fp, lpAnsiBuffer, cchBuffer, &cchBuffer, NULL);
|
|
}
|
|
|
|
LocalFree(lpAnsiBuffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void PromptUserForNtlmCredsTransfer()
|
|
{
|
|
WCHAR szMsg[MAX_PATH+1];
|
|
WCHAR rgchBuffer[MAX_PATH];
|
|
DWORD dwLength = 3; //including "\r\n"
|
|
WCHAR szZoneName[MAX_PATH+1];
|
|
DWORD dwZonePolicy = URLPOLICY_CREDENTIALS_SILENT_LOGON_OK; //anything other than anonymous
|
|
ui.bSendCredsToRemoteSite = FALSE;
|
|
ui.bPromptForNtlm = FALSE;
|
|
|
|
wcscpy( szZoneName, L"" );//no overflow.
|
|
if( !IsTrustedServer( rgchHostName, szZoneName, sizeof(szZoneName)/sizeof(WCHAR), &dwZonePolicy ) )
|
|
{
|
|
if( URLPOLICY_CREDENTIALS_ANONYMOUS_ONLY != dwZonePolicy )
|
|
{
|
|
LoadString( ghInstance, IDS_NTLM_PROMPT, szMsg, MAX_PATH);
|
|
|
|
Write( szMsg, szZoneName, NULL );
|
|
|
|
rgchBuffer[0] = L'N';
|
|
if( !ReadConsole( gwi.hInput, rgchBuffer, dwLength, &dwLength, NULL ) )
|
|
{
|
|
goto PromptUserIfNtlmAbort;
|
|
}
|
|
|
|
|
|
if( 0 == dwLength ) //when ctrl C is pressed
|
|
{
|
|
rgchBuffer[0] = L'N';
|
|
}
|
|
|
|
if((towupper(rgchBuffer[0])) == L'Y' )
|
|
{
|
|
ui.bSendCredsToRemoteSite = TRUE;
|
|
goto PromptUserIfNtlmAbort;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ui.bSendCredsToRemoteSite = TRUE;
|
|
}
|
|
|
|
PromptUserIfNtlmAbort:
|
|
return;
|
|
}
|
|
|
|
#define MAX_TELNET_COMMANDS 9
|
|
//#endif /* FE_IME */
|
|
|
|
|
|
static TelnetCommand sTelnetCommands[MAX_TELNET_COMMANDS];
|
|
|
|
BOOL PrintHelpStr(LPTSTR szCommand)
|
|
{
|
|
DWORD dwWritten;
|
|
WriteConsole(gwi.hOutput, szHelp, _tcslen(szHelp), &dwWritten, NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
//This uses the global variable g_chEsc and forms a global string g_szKbdEscape
|
|
void SetEscapeChar( WCHAR chEsc )
|
|
{
|
|
USHORT vkBracket = 0;
|
|
UINT iRet = 0;
|
|
WCHAR szShiftState[ MAX_STRING_LENGTH ];
|
|
LPWSTR szTmpShiftState = szShiftState;
|
|
|
|
SfuZeroMemory(g_szKbdEscape, sizeof(g_szKbdEscape));
|
|
|
|
CheckEscCharState( &vkBracket, &iRet, chEsc, szTmpShiftState );
|
|
g_chEsc = chEsc;
|
|
if( 0 == iRet )
|
|
{
|
|
wcscpy( szShiftState, L"" );//no overflow.
|
|
}
|
|
//
|
|
// If VirtualKey exists then map it into a character
|
|
//
|
|
if(LOBYTE(vkBracket) != (BYTE)-1)
|
|
{
|
|
|
|
//
|
|
// If a key does not exist, goto default mapping
|
|
//
|
|
if( 0 == iRet )
|
|
{
|
|
chEsc = L']';
|
|
g_chEsc = DEFAULT_ESCAPE_CHAR;
|
|
g_EscCharShiftState = DEFAULT_SHIFT_STATE;
|
|
}
|
|
else
|
|
{
|
|
chEsc = LOBYTE( iRet );
|
|
}
|
|
if( isalpha( chEsc ) )
|
|
{
|
|
chEsc = (SHORT) tolower( chEsc );
|
|
}
|
|
}
|
|
|
|
_sntprintf(g_szKbdEscape,SMALL_STRING, szEscapeChar, szShiftState, chEsc);
|
|
}
|
|
|
|
void CheckEscCharState( USHORT *ptrvkBracket, UINT *ptriRet, WCHAR chEscKey, LPWSTR szEscCharShiftState )
|
|
{
|
|
DWORD dwToCopy = MAX_STRING_LENGTH-1;
|
|
*ptrvkBracket = VkKeyScan(chEscKey);
|
|
|
|
|
|
*ptriRet = MapVirtualKey(LOBYTE(*ptrvkBracket), 2);
|
|
if( *ptriRet != 0 )
|
|
{
|
|
g_EscCharShiftState = HIBYTE( *ptrvkBracket );
|
|
}
|
|
|
|
|
|
wcscpy( szEscCharShiftState, ( LPTSTR )L"" );//no overflow.
|
|
if( g_EscCharShiftState & SHIFT_KEY )
|
|
{
|
|
_snwprintf( szEscCharShiftState,dwToCopy,( LPTSTR )L"%s", SHIFT_PLUS );
|
|
szEscCharShiftState+= wcslen( szEscCharShiftState);
|
|
dwToCopy -= wcslen(szEscCharShiftState);
|
|
}
|
|
if( g_EscCharShiftState & ALT_KEY )
|
|
{
|
|
_snwprintf( szEscCharShiftState,dwToCopy,( LPTSTR )L"%s", ALT_PLUS );
|
|
szEscCharShiftState += wcslen( szEscCharShiftState );
|
|
dwToCopy -= wcslen(szEscCharShiftState);
|
|
}
|
|
if( g_EscCharShiftState & CTRL_KEY )
|
|
{
|
|
_snwprintf( szEscCharShiftState, dwToCopy,( LPTSTR )L"%s", CTRL_PLUS );
|
|
}
|
|
}
|
|
|
|
DWORD g_lExitTelnet = 0;
|
|
|
|
DWORD DoTelnetCommands( void* p )
|
|
{
|
|
#define MAX_COMMAND_LEN 256
|
|
|
|
// make the command buffer hold 256 characters and null terminatior. Note that
|
|
// ReadConsole when asked to read 255 characters, will read 254 and the <CR> character
|
|
// and then real <LF> in the next call. Where as if we ask it to read 256, it will still limit no
|
|
// of characters to 254, but this time return both <CR>, <LF>.
|
|
|
|
TCHAR szCommand[MAX_COMMAND_LEN+1];
|
|
TCHAR *pCmd = NULL;
|
|
DWORD dwRead = ( DWORD ) -1, dwWritten = 0;
|
|
int iBegin = 0, iEnd = 0, iCmd = 0;
|
|
static DWORD dwConsoleMode = 0;
|
|
|
|
TCHAR szTmp[MAX_COMMAND_LEN] = { 0 };
|
|
TCHAR szTmp1[81];
|
|
if( dwConsoleMode == 0 )
|
|
GetConsoleMode( gwi.hInput, &dwConsoleMode );
|
|
|
|
SetEscapeChar( g_chEsc ); //This forms g_szKbdEscape
|
|
_sntprintf(szTmp,MAX_COMMAND_LEN -1,_T("%s%s%s"),szInfoBanner,g_szKbdEscape,TEXT("\n"));
|
|
WriteConsole( gwi.hOutput, szTmp, _tcslen(szTmp), &dwWritten, NULL);
|
|
// hack to make the command line paramater to work.
|
|
if( rgchHostName[0] )
|
|
{
|
|
//ugly hack due to remnants of old logic
|
|
//by this point, we have already done this kind of stuff once in
|
|
//FInitApplication()
|
|
TCHAR szCmd[MAX_COMMAND_LEN] = { 0 };
|
|
|
|
if( g_szPortNameOrNo[ 0 ] != 0 ) //not a null string
|
|
{
|
|
_sntprintf(szCmd,MAX_COMMAND_LEN -1,TEXT("%s %s"),rgchHostName,g_szPortNameOrNo);
|
|
}
|
|
else
|
|
{
|
|
_tcsncpy( szCmd, rgchHostName,MAX_COMMAND_LEN -1);
|
|
}
|
|
fPrintMessageToSessionConsole = TRUE;
|
|
fClientLaunchedFromCommandPrompt = TRUE;
|
|
OpenTelnetSession( szCmd );
|
|
if( g_fConnectFailed )
|
|
{
|
|
exit( 0 );
|
|
}
|
|
}
|
|
|
|
do {
|
|
int iValidCmd = -1;
|
|
int iIndex = 0;
|
|
int iCount = 0;
|
|
BOOL dwStatus = 0;
|
|
|
|
if( ui.bPromptForNtlm )
|
|
{
|
|
gwi.hOutput = g_hTelnetPromptConsoleBuffer;
|
|
SetConsoleActiveScreenBuffer( gwi.hOutput );
|
|
PromptUserForNtlmCredsTransfer();
|
|
ui.bPromptForNtlm = FALSE;
|
|
SetEvent( g_hCaptureConsoleEvent );
|
|
gwi.hOutput = g_hSessionConsoleBuffer;
|
|
SetConsoleActiveScreenBuffer( gwi.hOutput );
|
|
SetEvent( g_hRemoteNEscapeModeDataSync );
|
|
HandleTelnetSession(&gwi);
|
|
}
|
|
|
|
if( g_lExitTelnet )
|
|
{
|
|
CloseHandle(g_hTelnetPromptConsoleBuffer );
|
|
CloseHandle( gwi.hInput );
|
|
}
|
|
|
|
|
|
if( dwRead != 0 )
|
|
{
|
|
SetConsoleMode(gwi.hInput, dwConsoleMode);
|
|
gwi.hOutput = g_hTelnetPromptConsoleBuffer;
|
|
SetConsoleActiveScreenBuffer( gwi.hOutput );
|
|
WriteConsole( gwi.hOutput, szPrompt, _tcslen(szPrompt), &dwWritten, NULL);
|
|
SfuZeroMemory(szCommand, MAX_COMMAND_LEN * sizeof(TCHAR));
|
|
}
|
|
|
|
dwRead = ( DWORD ) -1;
|
|
dwStatus = ReadConsole(gwi.hInput, szCommand, MAX_COMMAND_LEN, &dwRead, NULL);
|
|
szCommand[MAX_COMMAND_LEN] = 0; // null terminate for the extreme case.
|
|
|
|
|
|
if( dwStatus == 0 || dwRead == -1 )
|
|
{
|
|
/* When NN_LOST is received, we close gwi.hInput so that we
|
|
* reach here and do equivalent of quit at telnet prompt */
|
|
QuitTelnet( ( LPTSTR )L"" );
|
|
continue;
|
|
}
|
|
|
|
if( dwRead == 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// no input ??
|
|
// This is the case when an enter is hit at telnet prompt
|
|
if ( dwRead == 2 )
|
|
{
|
|
if( fConnected )
|
|
{
|
|
gwi.hOutput = g_hSessionConsoleBuffer;
|
|
SetConsoleActiveScreenBuffer( gwi.hOutput );
|
|
SetEvent( g_hRemoteNEscapeModeDataSync );
|
|
HandleTelnetSession(&gwi);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
|
|
ASSERT( dwRead >= 2 );
|
|
|
|
// Null Terminate the string and remove the newline characters.
|
|
szCommand[dwRead-1] = 0;
|
|
szCommand[dwRead-2] = 0;
|
|
|
|
while( iswspace( szCommand[iIndex] ) )
|
|
{
|
|
iIndex++;
|
|
}
|
|
iCount = iIndex;
|
|
|
|
if( iIndex != 0 )
|
|
{
|
|
do
|
|
{
|
|
szCommand[ iIndex - iCount ] = szCommand[ iIndex++ ];
|
|
}
|
|
while( szCommand[ iIndex - 1 ] != _T('\0') );
|
|
}
|
|
|
|
if ( *szCommand == _T('?') )
|
|
{
|
|
PrintHelpStr(szCommand);
|
|
continue;
|
|
}
|
|
|
|
|
|
// do a binary search based on the first character, if that succeeds then
|
|
// see if the typed in command is a substring of the command.
|
|
iBegin = 0; iEnd = MAX_TELNET_COMMANDS - 1;
|
|
while ( iBegin <= iEnd )
|
|
{
|
|
iCmd = (iBegin + iEnd)/2;
|
|
if ( towlower( *szCommand ) == *sTelnetCommands[iCmd].sName )
|
|
break;
|
|
if ( towlower( *szCommand ) > *sTelnetCommands[iCmd].sName )
|
|
iBegin = iCmd+1;
|
|
else
|
|
iEnd = iCmd-1;
|
|
}
|
|
|
|
if ( iBegin > iEnd )
|
|
{
|
|
invalidCmd:
|
|
WriteConsole(gwi.hOutput, szInvalid, _tcslen(szInvalid), &dwWritten, NULL);
|
|
continue;
|
|
}
|
|
|
|
// go back to the command that has the same first char
|
|
while ( iCmd > 0 && towlower( *szCommand ) == *sTelnetCommands[iCmd-1].sName )
|
|
iCmd--;
|
|
|
|
pCmd = _tcstok(szCommand, ( LPTSTR )TEXT(" \t"));
|
|
if ( pCmd == NULL )
|
|
pCmd = szCommand;
|
|
|
|
while ( iCmd < MAX_TELNET_COMMANDS && towlower( *szCommand ) == *sTelnetCommands[iCmd].sName )
|
|
{
|
|
if ( _tcsstr(sTelnetCommands[iCmd].sName, _tcslwr( pCmd )) == sTelnetCommands[iCmd].sName)
|
|
{
|
|
if( iValidCmd >= 0 )
|
|
{
|
|
iValidCmd = -1;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
iValidCmd = iCmd;
|
|
}
|
|
}
|
|
iCmd++;
|
|
}
|
|
|
|
//if ( iCmd == MAX_TELNET_COMMANDS )
|
|
if( iValidCmd < 0 )
|
|
{
|
|
goto invalidCmd;
|
|
}
|
|
|
|
// process the command.
|
|
pCmd = _tcstok(NULL, ( LPTSTR )TEXT(""));
|
|
|
|
if ( (*sTelnetCommands[iValidCmd].pCmdHandler)(pCmd) )
|
|
break;
|
|
} while ( ( TRUE, TRUE ) );
|
|
|
|
return 0;
|
|
}
|
|
|
|
void SetCursorShape()
|
|
{
|
|
CONSOLE_CURSOR_INFO ccInfo = { 0 , 0 };
|
|
GetConsoleCursorInfo( g_hSessionConsoleBuffer, &ccInfo );
|
|
|
|
if( ccInfo.dwSize < BLOCK_CURSOR )
|
|
{
|
|
ccInfo.dwSize = BLOCK_CURSOR ;
|
|
}
|
|
else
|
|
{
|
|
ccInfo.dwSize = NORMAL_CURSOR;
|
|
}
|
|
SetConsoleCursorInfo( g_hSessionConsoleBuffer, &ccInfo );
|
|
|
|
return;
|
|
}
|
|
|
|
BOOL IsAnEscapeChar( WCHAR wcChar, WI *pwi, DWORD dwEventsRead )
|
|
{
|
|
PUCHAR destBuf = NULL;
|
|
DWORD dwSize = 0;
|
|
|
|
// Is it the escape Key !? i.e. ctrl + ]
|
|
if( wcChar == g_chEsc && g_bIsEscapeCharValid )
|
|
{
|
|
#if 0
|
|
//This special case is no more needed as we simulate key up and down
|
|
//for each key storke on the server. Lack of this was the cause of losing chars
|
|
//on the server side
|
|
|
|
// this is the really special case where when the user tries
|
|
// to enter ctrl + ], first he presses ctrl. this sends a
|
|
// ctrl "keydown" input record to the remote side .
|
|
// then we get the ctrl + ] and we switch to local mode.
|
|
// at this time the ctrl "keyup" input record is consumed by
|
|
// us locally. So we have to send a simulated ctrl "keyup"
|
|
// input record. Test case : when user is in app like
|
|
// "edit.exe", edit is expecting a ctrl "keyup" to follow
|
|
// a ctrl "keydown". otherwise it gets "stuck" and you can't
|
|
// enter the and letter keys.
|
|
//To solve this we are reading MAX_KEYUPS i/p records and
|
|
//giving them to the application
|
|
|
|
|
|
if( ( pwi->trm.CurrentTermType == TT_VTNT ) )
|
|
|
|
{
|
|
INPUT_RECORD pIR[ MAX_KEYUPS ];
|
|
ReadConsoleInput(pwi->hInput, pIR, MAX_KEYUPS, &dwEventsRead);
|
|
dwSize = sizeof( INPUT_RECORD ) * dwEventsRead;
|
|
if( !StuffEscapeIACs( &destBuf, (PUCHAR) pIR, &dwSize ) )
|
|
{
|
|
FWriteToNet( pwi, ( CHAR* ) pIR, dwSize );
|
|
}
|
|
else
|
|
{
|
|
FWriteToNet(pwi, ( CHAR* )destBuf, dwSize );
|
|
dwSize = 0;
|
|
free( destBuf );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//Failure of this is not serious. Just that
|
|
//Remote data may be seen escape mode.
|
|
WaitForSingleObject( g_hRemoteNEscapeModeDataSync, INFINITE );
|
|
ResetEvent( g_hRemoteNEscapeModeDataSync );
|
|
|
|
gwi.hOutput = g_hTelnetPromptConsoleBuffer;
|
|
|
|
return ( TRUE );
|
|
}
|
|
|
|
return ( FALSE );
|
|
}
|
|
|
|
/*
|
|
*
|
|
* This function does all the characater translations/mappings
|
|
* that are required by the client to do. This function has
|
|
* to be called after a Key Event has occurred and before
|
|
* anything is written onto the socket. All other places
|
|
* where the translations/mappings are being done are to be
|
|
* removed.
|
|
*
|
|
* TODO: Right now I am moving delasbs and bsasdel mappings
|
|
* only to fix a few bugs. All mappings should eventually be
|
|
* moved here for better maintainability - prakashr
|
|
*
|
|
*/
|
|
void HandleCharMappings(WI* pWI, INPUT_RECORD* pInputRecord)
|
|
{
|
|
// Do not make a call to ForceJISRomanSend in this function
|
|
// that will be done while sending the data to the network
|
|
|
|
// Map backspace to del, in case of 'set bsasdel' setting
|
|
// unless either CTRL or SHIFT or ALT is pressed
|
|
if (g_bSendBackSpaceAsDel && pInputRecord->Event.KeyEvent.uChar.AsciiChar == ASCII_BACKSPACE &&
|
|
!(pInputRecord->Event.KeyEvent.dwControlKeyState & (ALT_PRESSED | CTRL_PRESSED | SHIFT_PRESSED)))
|
|
{
|
|
pInputRecord->Event.KeyEvent.wVirtualKeyCode = VK_DELETE;
|
|
pInputRecord->Event.KeyEvent.uChar.AsciiChar = CHAR_NUL;
|
|
pInputRecord->Event.KeyEvent.dwControlKeyState |= ENHANCED_KEY;
|
|
return;
|
|
}
|
|
|
|
// Map del to backspace, in case of 'set delasbs' setting
|
|
// unless either CTRL or SHIFT or ALT is pressed
|
|
if (g_bSendDelAsBackSpace && pInputRecord->Event.KeyEvent.wVirtualKeyCode == VK_DELETE &&
|
|
!(pInputRecord->Event.KeyEvent.dwControlKeyState & (ALT_PRESSED | CTRL_PRESSED | SHIFT_PRESSED)))
|
|
{
|
|
pInputRecord->Event.KeyEvent.uChar.AsciiChar = ASCII_BACKSPACE;
|
|
pInputRecord->Event.KeyEvent.wVirtualKeyCode = ASCII_BACKSPACE;
|
|
pInputRecord->Event.KeyEvent.dwControlKeyState &= ~ENHANCED_KEY;
|
|
return;
|
|
}
|
|
}
|
|
|
|
DWORD HandleTelnetSession(WI *pwi)
|
|
{
|
|
PUCHAR destBuf = NULL;
|
|
DWORD dwSize = 0;
|
|
BOOL bBreakFlag = FALSE;
|
|
|
|
INPUT_RECORD sInputRecord;
|
|
DWORD dwEventsRead;
|
|
INPUT_RECORD *pInputRecord;
|
|
DWORD dwPrevMode = 0, TelnetConsoleMode;
|
|
|
|
GetConsoleMode(pwi->hInput, &dwPrevMode);
|
|
|
|
TelnetConsoleMode = dwPrevMode & ~(ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | FOCUS_EVENT);
|
|
|
|
SetConsoleMode(pwi->hInput, TelnetConsoleMode);
|
|
|
|
pInputRecord = &sInputRecord;
|
|
|
|
// DebugBreak();
|
|
|
|
while ( fConnected && !bBreakFlag )
|
|
{
|
|
if ( (pwi->trm.CurrentTermType == TT_VTNT) ?
|
|
ReadConsoleInput(pwi->hInput, pInputRecord, 1, &dwEventsRead) :
|
|
ReadConsoleInputA(pwi->hInput, pInputRecord, 1, &dwEventsRead))
|
|
{
|
|
|
|
|
|
switch ( pInputRecord->EventType )
|
|
{
|
|
case KEY_EVENT:
|
|
|
|
if (!FGetCodeMode(eCodeModeFarEast) && !FGetCodeMode(eCodeModeVT80))
|
|
{
|
|
// If ALT key is down and we are not in VTNT mode we check to see if
|
|
// user wants to enter extended ASCII characters from the OEM character
|
|
// set or from ANSI character set. Also note that currently in V1 the
|
|
// SFU server does term type negotiation only after user login.
|
|
// So the term type will be ANSI until login succeeds eventhough the
|
|
// user sets the preferred term type to VTNT. Unless this protocol ordering
|
|
// changes in the server, the below loop will work for VTNT when the
|
|
// username or password has extended characters in it.
|
|
//
|
|
if( (pInputRecord->Event.KeyEvent.dwControlKeyState & ALT_PRESSED) &&
|
|
(pwi->trm.CurrentTermType != TT_VTNT) )
|
|
{
|
|
char szExtendedCharBuf[5];
|
|
int idx=0;
|
|
SfuZeroMemory( szExtendedCharBuf, sizeof(szExtendedCharBuf) );
|
|
|
|
while(fConnected)
|
|
{
|
|
ReadConsoleInputA( pwi->hInput, pInputRecord, 1, &dwEventsRead );
|
|
/*++
|
|
Continue here ONLY if the client is still connected - which is determined by the
|
|
fConnected flag. Otherwise, break from this loop without doing anything.
|
|
--*/
|
|
if ( FOCUS_EVENT == pInputRecord->EventType
|
|
&& TRUE == ui.bPromptForNtlm )
|
|
{
|
|
bBreakFlag = TRUE;
|
|
break;
|
|
}
|
|
|
|
if( !(pInputRecord->Event.KeyEvent.dwControlKeyState & ALT_PRESSED)
|
|
|| (pInputRecord->EventType != KEY_EVENT)
|
|
|| !( ( pInputRecord->Event.KeyEvent.wVirtualKeyCode >= VK_NUMPAD0
|
|
&& pInputRecord->Event.KeyEvent.wVirtualKeyCode <= VK_NUMPAD9 )
|
|
|| IS_NUMPAD_DIGIT_KEY( pInputRecord->Event.KeyEvent ) ) )
|
|
//The last one is for allowing entering extended
|
|
//chars even when numlock is not on
|
|
{
|
|
if( idx == NUM_ISO8859_CHARS )
|
|
{
|
|
int extChar;
|
|
WCHAR wcChar[2] = {0};
|
|
CHAR cChar[2] = {0};
|
|
CHAR cSpace = ' ';
|
|
BOOL bUsed = 0;
|
|
|
|
szExtendedCharBuf[idx] = '\0';
|
|
extChar = atoi( szExtendedCharBuf );
|
|
|
|
/* When casting from int to char, it is using
|
|
* CP 1252. To make it use 850, the following jugglery */
|
|
|
|
MultiByteToWideChar( GetConsoleCP(), 0, ( LPCSTR )&extChar, 1, &wcChar[0], 1 );
|
|
wcChar[1] = L'\0';
|
|
WideCharToMultiByte( GetConsoleCP(), 0, &wcChar[0], 1, &cChar[0], 1, &cSpace, &bUsed );
|
|
cChar[1] = '\0';
|
|
if( IsAnEscapeChar( wcChar[0], pwi, dwEventsRead ) )
|
|
{
|
|
// Restore the console mode.
|
|
SetConsoleMode( pwi->hInput, dwPrevMode );
|
|
return ( 0 );
|
|
}
|
|
HandleCharEvent( pwi, cChar[0], pInputRecord->Event.KeyEvent.dwControlKeyState );
|
|
break;
|
|
}
|
|
else if( idx == NUM_WINDOWS_CP1252_CHARS )
|
|
{
|
|
int extChar;
|
|
WCHAR wcChar[2] = {0};
|
|
CHAR cChar[2] = {0};
|
|
CHAR cSpace = ' ';
|
|
BOOL bUsed = 0;
|
|
|
|
szExtendedCharBuf[idx] = '\0';
|
|
extChar = atoi( szExtendedCharBuf );
|
|
|
|
MultiByteToWideChar( CP_ACP, 0, ( LPCSTR )&extChar, 1, &wcChar[0], 1 );
|
|
wcChar[1] = L'\0';
|
|
WideCharToMultiByte( GetConsoleCP(), 0, &wcChar[0], 1, &cChar[0], 1, &cSpace, &bUsed );
|
|
cChar[1] = '\0';
|
|
if( IsAnEscapeChar( wcChar[0], pwi, dwEventsRead ) )
|
|
{
|
|
// Restore the console mode.
|
|
SetConsoleMode( pwi->hInput, dwPrevMode );
|
|
return ( 0 );
|
|
}
|
|
HandleCharEvent( pwi, cChar[0], pInputRecord->Event.KeyEvent.dwControlKeyState );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if( (pInputRecord->Event.KeyEvent.uChar.AsciiChar != 0)
|
|
&& (pInputRecord->EventType == KEY_EVENT)
|
|
&& (pInputRecord->Event.KeyEvent.bKeyDown) )
|
|
{
|
|
break;
|
|
}
|
|
else if( ( ( pInputRecord->Event.KeyEvent.wVirtualKeyCode >= VK_PRIOR
|
|
&& pInputRecord->Event.KeyEvent.wVirtualKeyCode <= VK_DELETE )
|
|
|| ( pInputRecord->Event.KeyEvent.wVirtualKeyCode >= VK_F1
|
|
&& pInputRecord->Event.KeyEvent.wVirtualKeyCode <= VK_F12 ) )
|
|
&& pInputRecord->EventType == KEY_EVENT
|
|
&& pInputRecord->Event.KeyEvent.bKeyDown )
|
|
{
|
|
//This will handle home, end, pageup, pagedown, function keys etc from
|
|
//numeric keypad
|
|
break;
|
|
}
|
|
else if ( pInputRecord->Event.KeyEvent.dwControlKeyState & ENHANCED_KEY )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( IS_NUMPAD_DIGIT_KEY( pInputRecord->Event.KeyEvent ) )
|
|
{
|
|
INT iDigit = 0;
|
|
|
|
iDigit = MAP_DIGIT_KEYS_TO_VAL( pInputRecord->Event.KeyEvent.wVirtualKeyCode );
|
|
szExtendedCharBuf[idx++] = ( CHAR ) ( '0' + iDigit );
|
|
}
|
|
else
|
|
{
|
|
szExtendedCharBuf[idx++] = ( CHAR )( (pInputRecord->Event.KeyEvent.wVirtualKeyCode - VK_NUMPAD0) + '0' );
|
|
}
|
|
|
|
ReadConsoleInputA( pwi->hInput, pInputRecord, 1, &dwEventsRead );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
if( pInputRecord->Event.KeyEvent.bKeyDown )
|
|
{
|
|
if( IsAnEscapeChar( pInputRecord->Event.KeyEvent.uChar.UnicodeChar, pwi, dwEventsRead ) )
|
|
{
|
|
// Restore the console mode.
|
|
SetConsoleMode( pwi->hInput, dwPrevMode );
|
|
return ( 0 );
|
|
}
|
|
}
|
|
|
|
//
|
|
// After trapping the escape character, do the mappings now
|
|
//
|
|
HandleCharMappings(pwi, pInputRecord);
|
|
|
|
if( pwi->trm.CurrentTermType == TT_VTNT )
|
|
{
|
|
if( pInputRecord->Event.KeyEvent.wVirtualKeyCode == VK_INSERT_KEY &&
|
|
pInputRecord->Event.KeyEvent.bKeyDown )
|
|
{
|
|
SetCursorShape();
|
|
}
|
|
|
|
CheckForChangeInWindowSize();
|
|
|
|
dwSize = sizeof( INPUT_RECORD );
|
|
if( !StuffEscapeIACs( &destBuf, (PUCHAR) pInputRecord, &dwSize ) )
|
|
{
|
|
FWriteToNet( pwi, ( CHAR* ) pInputRecord, sizeof( INPUT_RECORD ) );
|
|
}
|
|
else
|
|
{
|
|
FWriteToNet(pwi, ( CHAR* )destBuf, dwSize );
|
|
dwSize = 0;
|
|
free( destBuf );
|
|
}
|
|
|
|
if( ui.nottelnet || (ui.fDebug & fdwLocalEcho ) )
|
|
{
|
|
//if( !DoVTNTOutput(pwi, &pwi->trm, sizeof(INPUT_RECORD),
|
|
// (char*)&sInputRecord ) )
|
|
//{
|
|
//pwi->trm.CurrentTermType = TT_ANSI;
|
|
//DoIBMANSIOutput(pwi, &pwi->trm,
|
|
//sizeof(INPUT_RECORD), (char*)&sInputRecord );
|
|
//}
|
|
}
|
|
break;
|
|
}
|
|
if ( ! pInputRecord->Event.KeyEvent.bKeyDown )
|
|
break;
|
|
|
|
if ( pInputRecord->Event.KeyEvent.dwControlKeyState & ENHANCED_KEY )
|
|
{
|
|
FHandleKeyDownEvent(pwi, (CHAR)pInputRecord->Event.KeyEvent.wVirtualKeyCode,
|
|
pInputRecord->Event.KeyEvent.dwControlKeyState);
|
|
break;
|
|
}
|
|
|
|
if ( pInputRecord->Event.KeyEvent.uChar.AsciiChar == 0 )
|
|
{
|
|
//The following call is for handling home, end, pageup, pagedown etc from
|
|
//numeric keypad and also, function keys
|
|
FHandleKeyDownEvent(pwi, (CHAR)pInputRecord->Event.KeyEvent.wVirtualKeyCode,
|
|
pInputRecord->Event.KeyEvent.dwControlKeyState);
|
|
break;
|
|
}
|
|
|
|
HandleCharEvent(pwi, pInputRecord->Event.KeyEvent.uChar.AsciiChar,
|
|
pInputRecord->Event.KeyEvent.dwControlKeyState);
|
|
break;
|
|
case MOUSE_EVENT:
|
|
break;
|
|
case WINDOW_BUFFER_SIZE_EVENT:
|
|
break;
|
|
case MENU_EVENT:
|
|
break;
|
|
case FOCUS_EVENT:
|
|
if(TRUE == ui.bPromptForNtlm)
|
|
{
|
|
bBreakFlag = TRUE;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
QuitTelnet( ( LPTSTR )L"" );
|
|
}
|
|
}
|
|
|
|
gwi.hOutput = g_hTelnetPromptConsoleBuffer;
|
|
bDoVtNTFirstTime = 1;
|
|
|
|
// Restore the console mode.
|
|
SetConsoleMode(pwi->hInput, dwPrevMode);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
BOOL WINAPI ControlHandler(DWORD dwCtrlType)
|
|
{
|
|
WCHAR wchCtrl;
|
|
|
|
switch ( dwCtrlType )
|
|
{
|
|
case CTRL_C_EVENT:
|
|
case CTRL_BREAK_EVENT:
|
|
if ( !fConnected ) // normal handling while not connected.
|
|
{
|
|
//
|
|
// (a-roopb) Fix to bug1006:telnet client does not connect when a ^C is hit
|
|
// SetEvent( g_hAsyncGetHostByNameEvent );
|
|
//
|
|
PulseEvent( g_hControlHandlerEvent );
|
|
return TRUE;
|
|
}
|
|
else if( gwi.hOutput != g_hSessionConsoleBuffer )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
// pass this to the server !!
|
|
if( gwi.trm.CurrentTermType == TT_VTNT )
|
|
{
|
|
wchCtrl = 0x03;
|
|
ConvertAndSendVTNTData(&wchCtrl,1);
|
|
|
|
if (ui.nottelnet || (ui.fDebug & fdwLocalEcho))
|
|
{
|
|
//if( !DoVTNTOutput( &gwi, &(gwi.trm), sizeof(INPUT_RECORD),
|
|
// (char*)&sInputRecord ) )
|
|
//{
|
|
//pwi->trm.CurrentTermType = TT_ANSI;
|
|
//DoIBMANSIOutput(&gwi, gwi.trm, sizeof(INPUT_RECORD),
|
|
// (char*)&sInputRecord );
|
|
//}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HandleCharEvent(&gwi, (CHAR)VK_CANCEL, // '0x03' i.e.
|
|
0);
|
|
}
|
|
break;
|
|
case CTRL_CLOSE_EVENT:
|
|
case CTRL_LOGOFF_EVENT:
|
|
case CTRL_SHUTDOWN_EVENT:
|
|
if ( fConnected )
|
|
FHangupConnection(&gwi, &(gwi.nd));
|
|
default:
|
|
return FALSE;
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void InitCodeModeFlags(UINT uConsoleCp)
|
|
{
|
|
switch (uConsoleCp)
|
|
{
|
|
case 932:
|
|
case 949:
|
|
case 936:
|
|
case 950:
|
|
SetCodeModeON(eCodeModeFarEast);
|
|
SetCodeModeON(eCodeModeIMEFarEast);
|
|
SetCodeModeON(eCodeModeVT80);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CleanUpMemory()
|
|
{
|
|
|
|
if( szUser )
|
|
{
|
|
free( szUser );
|
|
}
|
|
|
|
if( gwi.nd.lpReadBuffer )
|
|
{
|
|
(void)LocalFree( (HLOCAL)gwi.nd.lpReadBuffer );
|
|
gwi.nd.lpReadBuffer = NULL;
|
|
}
|
|
if( gwi.nd.lpTempBuffer )
|
|
{
|
|
(void)LocalFree( (HLOCAL)gwi.nd.lpTempBuffer );
|
|
gwi.nd.lpTempBuffer = NULL;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// CleanupProcess:
|
|
void DoProcessCleanup()
|
|
{
|
|
// first step is to close the Telnet connection if any
|
|
if ( fConnected )
|
|
FHangupConnection(&gwi, &(gwi.nd));
|
|
|
|
// next, free the Network resources.
|
|
WSACleanup(); // keithmo: get winsock.
|
|
|
|
// Destroy the window that we created.
|
|
DestroyWindow( gwi.hwnd );
|
|
CloseHandle(gwi.hNetworkThread);
|
|
CloseHandle(g_hControlHandlerEvent);
|
|
CloseHandle(g_hAsyncGetHostByNameEvent);
|
|
CloseHandle(g_hTelnetPromptConsoleBuffer );
|
|
CloseHandle(g_hRemoteNEscapeModeDataSync );
|
|
CloseHandle(g_hCaptureConsoleEvent);
|
|
|
|
|
|
|
|
// Cleanup the memory.
|
|
CleanUpMemory();
|
|
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: main()
|
|
|
|
PURPOSE: calls initialization function, processes message loop
|
|
|
|
COMMENTS:
|
|
|
|
Windows recognizes this function by name as the initial entry point
|
|
for the program. This function calls the application initialization
|
|
routine, if no other instance of the program is running, and always
|
|
calls the instance initialization routine. It then executes a message
|
|
retrieval and dispatch loop that is the top-level control structure
|
|
for the remainder of execution. The loop is terminated when a WM_QUIT
|
|
message is received, at which time this function exits the application
|
|
instance by returning the value passed by PostQuitMessage().
|
|
|
|
If this function must abort before entering the message loop, it
|
|
returns the conventional value NULL.
|
|
|
|
****************************************************************************/
|
|
|
|
int __cdecl wmain( int argc, TCHAR** argv )
|
|
{
|
|
MSG msg;
|
|
int err;
|
|
DWORD dwThreadId;
|
|
HANDLE hStdHandle = INVALID_HANDLE_VALUE;
|
|
|
|
setlocale(LC_ALL, "");
|
|
|
|
gwi.ichTelXfer = 0;
|
|
hStdHandle = GetStdHandle( STD_INPUT_HANDLE );
|
|
if( hStdHandle == INVALID_HANDLE_VALUE)
|
|
{
|
|
exit( -1 );
|
|
}
|
|
gwi.hInput = hStdHandle;
|
|
hStdHandle = GetStdHandle( STD_OUTPUT_HANDLE );
|
|
if( hStdHandle == INVALID_HANDLE_VALUE)
|
|
{
|
|
exit( -1 );
|
|
}
|
|
gwi.hOutput = hStdHandle;
|
|
g_hSessionConsoleBuffer = gwi.hOutput;
|
|
|
|
if( GetConsoleScreenBufferInfo( gwi.hOutput, &gwi.sbi ))
|
|
{
|
|
//set the initial console attributes
|
|
//white text on a black background
|
|
gwi.sbi.wAttributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
|
|
|
|
// This is so that when we scroll we maintain the
|
|
// background color & text color !!
|
|
gwi.cinfo.Attributes = gwi.sbi.wAttributes;
|
|
gwi.cinfo.Char.AsciiChar = ' ';
|
|
|
|
if(( err = FInitApplication( argc, argv, &gwi )))
|
|
{
|
|
exit( err );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
exit( -1 );
|
|
}
|
|
|
|
g_hControlHandlerEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); // Auto-Reset event
|
|
g_hAsyncGetHostByNameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); // Manual-Reset event
|
|
g_hCaptureConsoleEvent = CreateEvent( NULL, TRUE, TRUE, NULL ); // Manual-Reset event
|
|
|
|
|
|
// Create the thread that Handles the Keyboard and mouse input.
|
|
// The main thread has to keep dispatching the WinSock Messages since
|
|
// we use Non-Blocking sockets.
|
|
gwi.hNetworkThread = CreateThread( NULL, 0,
|
|
( LPTHREAD_START_ROUTINE )DoTelnetCommands, ( LPVOID ) &gwi, 0, &dwThreadId );
|
|
|
|
/* Acquire and dispatch messages until a WM_QUIT message is received. */
|
|
|
|
while ( GetMessage(&msg, gwi.hwnd, 0, 0) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
|
|
SetConsoleCtrlHandler(&ControlHandler, FALSE);
|
|
|
|
DoProcessCleanup();
|
|
|
|
// Save user settings.
|
|
SetUserSettings(&ui);
|
|
|
|
ExitProcess(0);
|
|
return 0;
|
|
}
|
|
|
|
void CreateTelnetPromptConsole()
|
|
{
|
|
//create a new console screen buffer. this is to be used for the remote
|
|
//session data
|
|
g_hTelnetPromptConsoleBuffer = CreateConsoleScreenBuffer(
|
|
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, CONSOLE_TEXTMODE_BUFFER, NULL );
|
|
|
|
if( g_hTelnetPromptConsoleBuffer == INVALID_HANDLE_VALUE )
|
|
{
|
|
exit( -1 );
|
|
}
|
|
|
|
SetConsoleScreenBufferSize( g_hTelnetPromptConsoleBuffer, gwi.sbi.dwSize );
|
|
gwi.hOutput = g_hTelnetPromptConsoleBuffer;
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: FInitApplication(HINSTANCE)
|
|
|
|
PURPOSE: Initializes window data and registers window class
|
|
|
|
COMMENTS:
|
|
|
|
This function is called at initialization time only if no other
|
|
instances of the application are running. This function performs
|
|
initialization tasks that can be done once for any number of running
|
|
instances.
|
|
|
|
In this case, we initialize a window class by filling out a data
|
|
structure of type WNDCLASS and calling the Windows RegisterClass()
|
|
function. Since all instances of this application use the same window
|
|
class, we only need to do this when the first instance is initialized.
|
|
|
|
|
|
****************************************************************************/
|
|
int
|
|
FInitApplication(int argc, TCHAR** argv, WI *pwi)
|
|
{
|
|
WNDCLASS wc;
|
|
#ifdef DEBUG
|
|
int argi; // for indexing argc.
|
|
#endif
|
|
|
|
WSADATA WsaData;
|
|
int WsaErr;
|
|
BOOL fServerFound = 0;
|
|
TCHAR rgchTerm[ 25 ]; //term type length is 25
|
|
|
|
InitCodeModeFlags(GetConsoleOutputCP());
|
|
|
|
/* Set the default user settings */
|
|
SfuZeroMemory(&ui, sizeof(UI));//no overflow. size constant.
|
|
|
|
ui.nottelnet = TRUE; // Assume that is not a telnet server that we would connect to ...
|
|
|
|
//Initialize logging related variables
|
|
ui.bLogging = FALSE;
|
|
ui.hLogFile = NULL;
|
|
|
|
ui.dwMaxRow = 0;
|
|
ui.dwMaxCol = 0;
|
|
|
|
CreateTelnetPromptConsole();
|
|
// We really do not care about the success or failure of this function.
|
|
HrLoadLocalizedLibrarySFU(GetModuleHandle(NULL), ( LPTSTR )L"telnetcr.dll", &ghInstance, NULL);
|
|
|
|
ASSERT(ghInstance);
|
|
|
|
#ifndef NO_PCHECK
|
|
#ifndef WHISTLER_BUILD
|
|
if ( !IsLicensedCopy() )
|
|
{
|
|
TCHAR g_szErrRegDelete[ MAX_STRING_LENGTH ];
|
|
LoadString(ghInstance, IDS_ERR_LICENSE, g_szErrRegDelete,
|
|
sizeof(g_szErrRegDelete) / sizeof(TCHAR));
|
|
MessageBox(NULL, g_szErrRegDelete, ( LPTSTR )_T(" "), MB_OK);
|
|
exit( 1 );
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
LoadString(ghInstance, IDS_APPNAME, (LPTSTR) szAppName, SMALL_STRING);
|
|
|
|
GetUserSettings(&ui);
|
|
|
|
ui.nCyChar = 1; // char height
|
|
ui.nCxChar = 1; // char width
|
|
|
|
WsaErr = WSAStartup( 0x0101, &WsaData ); // make sure winsock is happy - noop for now
|
|
|
|
if( WsaErr )
|
|
{
|
|
ErrorMessage(szCantInitSockets, szAppName);
|
|
SetLastError( WsaErr );
|
|
return WsaErr;
|
|
}
|
|
|
|
switch (GetConsoleOutputCP())
|
|
{
|
|
case 932:
|
|
case 949:
|
|
SetThreadLocale(
|
|
MAKELCID(
|
|
MAKELANGID( PRIMARYLANGID(GetSystemDefaultLangID()),
|
|
SUBLANG_ENGLISH_US),
|
|
SORT_DEFAULT
|
|
)
|
|
);
|
|
break;
|
|
case 936:
|
|
SetThreadLocale(
|
|
MAKELCID(
|
|
MAKELANGID( PRIMARYLANGID(GetSystemDefaultLangID()),
|
|
SUBLANG_CHINESE_SIMPLIFIED),
|
|
SORT_DEFAULT
|
|
)
|
|
);
|
|
break;
|
|
case 950:
|
|
SetThreadLocale(
|
|
MAKELCID(
|
|
MAKELANGID( PRIMARYLANGID(GetSystemDefaultLangID()),
|
|
SUBLANG_CHINESE_TRADITIONAL),
|
|
SORT_DEFAULT
|
|
)
|
|
);
|
|
break;
|
|
default:
|
|
SetThreadLocale(
|
|
MAKELCID(
|
|
MAKELANGID( LANG_ENGLISH,
|
|
SUBLANG_ENGLISH_US ),
|
|
SORT_DEFAULT
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
|
|
LoadString(ghInstance, IDS_USAGE, (LPTSTR) szUsage, 1399);
|
|
LoadString(ghInstance, IDS_VERSION, (LPTSTR) szVersion, SMALL_STRING);
|
|
LoadString(ghInstance, IDS_CONNECTIONLOST, (LPTSTR) szConnectionLost, 254);
|
|
LoadString(ghInstance, IDS_TITLEBASE, (LPTSTR) szTitleBase, SMALL_STRING);
|
|
LoadString(ghInstance, IDS_TITLENONE, (LPTSTR) szTitleNone, SMALL_STRING);
|
|
LoadString(ghInstance, IDS_TOOMUCHTEXT, (LPTSTR) szTooMuchText, 255);
|
|
LoadString(ghInstance, IDS_CONNECTING, (LPTSTR) szConnecting, SMALL_STRING);
|
|
LoadString(ghInstance, IDS_CONNECTFAILED, (LPTSTR) szConnectFailed, 254);
|
|
LoadString(ghInstance, IDS_CONNECTFAILEDMSG, (LPTSTR) szConnectFailedMsg, 254);
|
|
LoadString(ghInstance, IDS_ONPORT, szOnPort, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_CANT_INIT_SOCKETS, szCantInitSockets, SMALL_STRING );
|
|
|
|
LoadString(ghInstance, IDS_INFO_BANNER, szInfoBanner, 511 );
|
|
LoadString(ghInstance, IDS_ESCAPE_CHAR, szEscapeChar, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_PROMPT_STR, szPrompt, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_INVALID_STR, szInvalid, 254 );
|
|
LoadString(ghInstance, IDS_BUILD_INFO, szBuildInfo, 254 );
|
|
|
|
LoadString(ghInstance, IDS_CLOSE, szClose, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_DISPLAY, szDisplay, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_HELP, szHelpStr, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_OPEN, szOpen, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_OPENTO, szOpenTo, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_OPENUSAGE, szOpenUsage, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_QUIT, szQuit, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_SEND, szSend, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_SET, szSet, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_STATUS, szStatus, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_UNSET, szUnset, SMALL_STRING );
|
|
//#if defined(FE_IME)
|
|
// LoadString(ghInstance, IDS_ENABLE_IME_SUPPORT, szEnableIMESupport, SMALL_STRING );
|
|
// LoadString(ghInstance, IDS_DISABLE_IME_SUPPORT, szDisableIMESupport, SMALL_STRING );
|
|
//#endif /* FE_IME */
|
|
|
|
LoadString(ghInstance, IDS_WILL_AUTH, szWillAuth, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_WONT_AUTH, szWontAuth, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_LOCAL_ECHO_ON, szLocalEchoOn, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_LOCAL_ECHO_OFF, szLocalEchoOff, SMALL_STRING );
|
|
//#if defined(FE_IME)
|
|
// LoadString(ghInstance, IDS_ENABLE_IME_ON, szEnableIMEOn, SMALL_STRING );
|
|
//#endif /* FE_IME */
|
|
|
|
LoadString(ghInstance, IDS_CONNECTED_TO, szConnectedTo, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_NOT_CONNECTED, szNotConnected, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_NEGO_TERM_TYPE, szNegoTermType, SMALL_STRING );
|
|
LoadString(ghInstance, IDS_PREF_TERM_TYPE, szPrefTermType, 255 );
|
|
|
|
LoadString(ghInstance, IDS_SET_FORMAT, szSetFormat, 254 );
|
|
LoadString(ghInstance, IDS_SUPPORTED_TERMS, szSupportedTerms, 254 );
|
|
LoadString(ghInstance, IDS_UNSET_FORMAT, szUnsetFormat, 254 );
|
|
|
|
if((GetACP() == JAP_CODEPAGE) && FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80))
|
|
{
|
|
LoadString(ghInstance, IDS_SET_HELP_JAP, szSetHelp, 1023 );
|
|
LoadString(ghInstance, IDS_UNSET_HELP_JAP, szUnsetHelp, 1023 );
|
|
LoadString(ghInstance, IDS_HELP_STR_JAP, szHelp, 1023 );
|
|
}
|
|
else
|
|
{
|
|
LoadString(ghInstance, IDS_SET_HELP, szSetHelp, 1023 );
|
|
LoadString(ghInstance, IDS_UNSET_HELP, szUnsetHelp, 1023 );
|
|
LoadString(ghInstance, IDS_HELP_STR, szHelp, 1023 );
|
|
}
|
|
|
|
//#if defined(FE_IME)
|
|
// LoadString(ghInstance, IDS_ENABLE_IME_FORMAT, szEnableIMEFormat, SMALL_STRING );
|
|
// LoadString(ghInstance, IDS_ENABLE_IME_HELP, szEnableIMEHelp, 254 );
|
|
// LoadString(ghInstance, IDS_DISABLE_IME_FORMAT, szDisableIMEFormat, SMALL_STRING );
|
|
// LoadString(ghInstance, IDS_DISABLE_IME_HELP, szDisableIMEHelp, 254 );
|
|
//#endif /* FE_IME */
|
|
|
|
//LoadString(ghInstance, IDS_ESCAPE_CHARACTER, szEscapeCharacter, 2 );
|
|
|
|
|
|
SetEnvironmentVariable( TEXT( SFUTLNTVER ), TEXT( "2" ) );
|
|
|
|
wcscpy( szUserName, ( LPTSTR )L""); //This is used as a flag to detect presence of
|
|
// -l -a options.
|
|
//no overflow.
|
|
wcscpy( g_szLogFile, ( LPTSTR )L"" );//no overflow.
|
|
if(argc > 1)
|
|
{
|
|
INT i = 1;
|
|
while( i < argc )
|
|
{
|
|
if( argv[i][0] == L'-' || argv[i][0] == L'/' )
|
|
{
|
|
switch( argv[i][ 1 ] )
|
|
{
|
|
case L'f':
|
|
case L'F':
|
|
if( argv[i][2] == L'\0' )
|
|
{
|
|
if( ++i >= argc )
|
|
{
|
|
//exit with usage message
|
|
i--;
|
|
argv[i][0] = L'-';
|
|
argv[i][1] = L'?';
|
|
continue;
|
|
}
|
|
|
|
_tcsncpy( g_szLogFile, argv[i],
|
|
min( _tcslen(argv[i]) + 1, MAX_PATH + 1 ) );
|
|
}
|
|
else
|
|
{
|
|
_tcsncpy( g_szLogFile, ( argv[i] + wcslen( ( LPWSTR )L"-f" ) ),
|
|
min( _tcslen(argv[i]) + 1, MAX_PATH + 1 ) );
|
|
}
|
|
g_szLogFile[ MAX_PATH + 1 ] = L'\0';
|
|
if( !InitLogFile( g_szLogFile ) )
|
|
{
|
|
DWORD dwWritten = 0;
|
|
TCHAR szMsg[ MAX_STRING_LENGTH ];
|
|
LoadString( ghInstance, IDS_BAD_LOGFILE, szMsg, MAX_STRING_LENGTH );
|
|
WriteConsole( g_hSessionConsoleBuffer, szMsg,
|
|
_tcslen(szMsg), &dwWritten, NULL);
|
|
exit(0);
|
|
}
|
|
ui.bLogging = TRUE;
|
|
break;
|
|
|
|
case L'l':
|
|
case L'L':
|
|
if( argv[i][2] == L'\0' )
|
|
{
|
|
if( ++i >= argc )
|
|
{
|
|
//exit with usage message
|
|
i--;
|
|
argv[i][0] = L'-';
|
|
argv[i][1] = L'?';
|
|
continue;
|
|
}
|
|
|
|
_tcsncpy( szUserName, argv[i],
|
|
min( _tcslen(argv[i]) + 1, UNLEN ) );
|
|
}
|
|
else
|
|
{
|
|
//when the term name is given after -t without
|
|
//any spaces. 2 accounts for -t.
|
|
_tcsncpy( szUserName, ( argv[i] + 2 ),
|
|
min( _tcslen(argv[i]) - 1, UNLEN ) );
|
|
}
|
|
//Will help if a loooong user name is given
|
|
szUserName[ UNLEN ] = L'\0';
|
|
break;
|
|
case L'a':
|
|
case L'A':
|
|
if( argv[i][2] == L'\0' )
|
|
{
|
|
DWORD dwSize = UNLEN + 1;
|
|
GetUserName( szUserName, &dwSize );
|
|
}
|
|
else
|
|
{
|
|
argv[i][1] = L'?'; //go back and print usage message
|
|
i--;
|
|
}
|
|
break;
|
|
|
|
case L'e':
|
|
case L'E':
|
|
if( argv[i][2] == L'\0' )
|
|
{
|
|
if( ++i >= argc )
|
|
{
|
|
//exit with usage message
|
|
i--;
|
|
argv[i][0] = L'-';
|
|
argv[i][1] = L'?';
|
|
continue;
|
|
}
|
|
|
|
g_chEsc = argv[i][0]; //Get the first char
|
|
}
|
|
else
|
|
{
|
|
g_chEsc = argv[i][2]; //Get the first char
|
|
}
|
|
break;
|
|
|
|
case L't':
|
|
case L'T':
|
|
if( argv[i][2] == L'\0' )
|
|
{
|
|
if( ++i >= argc )
|
|
{
|
|
//exit with usage message
|
|
i--;
|
|
argv[i][0] = L'-';
|
|
argv[i][1] = L'?';
|
|
continue;
|
|
}
|
|
|
|
_tcsncpy( rgchTerm, argv[i],
|
|
min( _tcslen(argv[i]) + 1, 24 ) );
|
|
}
|
|
else
|
|
{
|
|
//when the term name is given after -t without
|
|
//any spaces. 2 accounts for -t.
|
|
_tcsncpy( rgchTerm, ( argv[i] + 2 ),
|
|
min( _tcslen(argv[i]) - 1, 24 ) );
|
|
}
|
|
//This statement is helpful only when term type
|
|
//length exceeds 24 chars.
|
|
rgchTerm[24] = L'\0';
|
|
gwi.trm.RequestedTermType =
|
|
GetRequestedTermType( rgchTerm );
|
|
if( gwi.trm.RequestedTermType < 0 )
|
|
{
|
|
DWORD dwWritten;
|
|
WriteConsole(g_hSessionConsoleBuffer, szSupportedTerms,
|
|
_tcslen(szSupportedTerms), &dwWritten, NULL);
|
|
exit(0);
|
|
}
|
|
break;
|
|
case L'?':
|
|
default:
|
|
PrintUsage();
|
|
exit(0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( fServerFound )
|
|
{
|
|
PrintUsage();
|
|
exit(0);
|
|
}
|
|
fServerFound = 1;
|
|
_tcsncpy( rgchHostName, argv[i],
|
|
min( _tcslen(argv[i]), cchMaxHostName/sizeof(TCHAR) -
|
|
sizeof(TCHAR) ));
|
|
|
|
g_szPortNameOrNo[ 0 ] = 0;
|
|
if( ++i >= argc )
|
|
{
|
|
continue;
|
|
}
|
|
if( IsCharAlpha( argv[i][0] ) ||
|
|
IsCharAlphaNumeric( argv[i][0] ) )
|
|
{
|
|
_tcsncpy( g_szPortNameOrNo, argv[i],
|
|
min( _tcslen(argv[i]), cchMaxHostName -
|
|
sizeof(TCHAR) ));
|
|
|
|
g_szPortNameOrNo[ cchMaxHostName -1 ] = 0;
|
|
|
|
}
|
|
else
|
|
{
|
|
// neither a port number nor a string representing
|
|
// a service. need to print usage
|
|
i--;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
//MBSC user name value now available in szUser
|
|
if( wcscmp( szUserName, ( LPTSTR )L"" ) != 0 )
|
|
{
|
|
DWORD dwNum = 0;
|
|
|
|
dwNum = WideCharToMultiByte( GetConsoleCP(), 0, szUserName, -1, NULL, 0, NULL, NULL );
|
|
if(dwNum)
|
|
szUser = ( CHAR * ) malloc( dwNum * sizeof( CHAR ) );
|
|
else
|
|
return 0;
|
|
if( !szUser )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
dwNum = WideCharToMultiByte( GetConsoleCP(), 0, szUserName, -1, szUser, dwNum, NULL, NULL );
|
|
}
|
|
|
|
sTelnetCommands[0].sName = szClose;
|
|
sTelnetCommands[0].pCmdHandler = CloseTelnetSession;
|
|
|
|
sTelnetCommands[1].sName = szDisplay;
|
|
sTelnetCommands[1].pCmdHandler = DisplayParameters;
|
|
|
|
sTelnetCommands[2].sName = szHelpStr;
|
|
sTelnetCommands[2].pCmdHandler = PrintHelpStr;
|
|
|
|
sTelnetCommands[3].sName = szOpen;
|
|
sTelnetCommands[3].pCmdHandler = OpenTelnetSession;
|
|
|
|
sTelnetCommands[4].sName = szQuit;
|
|
sTelnetCommands[4].pCmdHandler = QuitTelnet;
|
|
|
|
sTelnetCommands[5].sName = szSend;
|
|
sTelnetCommands[5].pCmdHandler = SendOptions;
|
|
|
|
sTelnetCommands[6].sName = szSet;
|
|
sTelnetCommands[6].pCmdHandler = SetOptions;
|
|
|
|
sTelnetCommands[7].sName = szStatus;
|
|
sTelnetCommands[7].pCmdHandler = PrintStatus;
|
|
|
|
sTelnetCommands[8].sName = szUnset;
|
|
sTelnetCommands[8].pCmdHandler = UnsetOptions;
|
|
|
|
if (FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80))
|
|
|
|
{
|
|
int i;
|
|
|
|
for( i=0 ; i<NUMBER_OF_KANJI ; i++ )
|
|
{
|
|
LoadString(ghInstance, KanjiList[i].KanjiMessageID,
|
|
KanjiList[i].KanjiDescription, 255);
|
|
}
|
|
|
|
LoadString(ghInstance, IDS_VT100KANJI_EMULATION, szVT100KanjiEmulation, SMALL_STRING);
|
|
}
|
|
|
|
// Setup the Handle Routine for Ctrl-C etc.
|
|
SetConsoleCtrlHandler(&ControlHandler, TRUE);
|
|
|
|
/* Fill in window class structure with parameters that describe the
|
|
* main window.
|
|
*/
|
|
wc.style = CS_VREDRAW | CS_HREDRAW;
|
|
wc.lpfnWndProc = MainWndProc;
|
|
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = sizeof(HANDLE)+sizeof(SVI *);
|
|
wc.hInstance = ghInstance;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = NULL;
|
|
wc.hbrBackground= ( HBRUSH )( COLOR_WINDOW + 1 );
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName= ( LPTSTR )TEXT("TelnetClient");
|
|
|
|
/* Register the window class and return success/failure code. */
|
|
if ( RegisterClass(&wc) == 0 )
|
|
return GetLastError();
|
|
|
|
pwi->hwnd = CreateWindow( ( LPTSTR )TEXT("TelnetClient"),
|
|
NULL,
|
|
WS_POPUP, // not visible
|
|
0, 0, 0, 0, // not height or width
|
|
NULL, NULL, ghInstance, (LPVOID)pwi);
|
|
|
|
if ( pwi->hwnd == NULL )
|
|
return GetLastError();
|
|
|
|
g_hRemoteNEscapeModeDataSync = CreateEvent( NULL, TRUE, TRUE, NULL );
|
|
if( !g_hRemoteNEscapeModeDataSync )
|
|
{
|
|
return GetLastError();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// maps window messages to their names.
|
|
|
|
/****************************************************************************
|
|
|
|
FUNCTION: MainWndProc(HWND, UINT, WPARAM, LPARAM)
|
|
|
|
PURPOSE: Processes messages
|
|
|
|
COMMENTS:
|
|
|
|
To process the IDM_ABOUT message, call MakeProcInstance() to get the
|
|
current instance address of the About() function. Then call Dialog
|
|
box which will create the box according to the information in your
|
|
WinTel.rc file and turn control over to the About() function. When
|
|
it returns, free the intance address.
|
|
|
|
****************************************************************************/
|
|
LRESULT CALLBACK
|
|
MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
static HANDLE hInst = NULL;
|
|
static BOOL fInited = FALSE;
|
|
WI *pwi = NULL;
|
|
BOOL fRet = FALSE;
|
|
|
|
CHARSETINFO csi;
|
|
DWORD_PTR dw;
|
|
|
|
if ( message != WM_CREATE )
|
|
pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
|
|
|
|
switch ( message )
|
|
{
|
|
case WM_CREATE:
|
|
|
|
DEBUG_PRINT(("WM_CREATE received\n"));
|
|
|
|
hInst = ((LPCREATESTRUCT)lParam)->hInstance;
|
|
|
|
pwi = (WI *)((LPCREATESTRUCT)lParam)->lpCreateParams;
|
|
|
|
SetWindowLongPtr(hwnd, WL_TelWI, (LONG_PTR)pwi);
|
|
|
|
fHungUp = FALSE;
|
|
|
|
if( FGetCodeMode(eCodeModeIMEFarEast) )
|
|
{
|
|
if ( ui.fDebug & fdwKanjiModeMask )
|
|
{
|
|
|
|
dw = GetACP();
|
|
|
|
if (!TranslateCharsetInfo((DWORD*)dw, &csi, TCI_SRCCODEPAGE))
|
|
{
|
|
csi.ciCharset = ANSI_CHARSET;
|
|
}
|
|
|
|
ui.lf.lfCharSet = (UCHAR)csi.ciCharset;
|
|
ui.lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
|
|
ui.lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
|
|
ui.lf.lfQuality = DEFAULT_QUALITY;
|
|
ui.lf.lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
|
|
|
|
|
|
//
|
|
// Get IME Input Context.
|
|
//
|
|
hImeContext = ImmGetContext(hwnd);
|
|
|
|
//
|
|
// Assoicate current font to Input Context.
|
|
//
|
|
ImmSetCompositionFont(hImeContext,&ui.lf);
|
|
}
|
|
}
|
|
|
|
if (FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80))
|
|
// (a-roopb) we set this in GetUserSettings()
|
|
// pwi->trm.puchCharSet = rgchCharSetWorkArea;
|
|
// if(!SetConsoleOutputCP(932))
|
|
// MessageBox(NULL, _T("Failed to load Codepage 932"), _T("ERROR"), MB_OK);
|
|
;
|
|
else
|
|
pwi->trm.puchCharSet = rgchNormalChars;
|
|
|
|
if (pwi->nd.lpReadBuffer = (LPSTR)LocalAlloc(LPTR, sizeof(UCHAR)*READ_BUF_SZ))
|
|
{
|
|
pwi->nd.SessionNumber = nSessionNone;
|
|
|
|
fRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DestroyWindow( hwnd );
|
|
break;
|
|
}
|
|
if (!(pwi->nd.lpTempBuffer = (LPSTR)LocalAlloc(LPTR, sizeof(UCHAR)*READ_BUF_SZ)))
|
|
{
|
|
DestroyWindow( hwnd );
|
|
break;
|
|
}
|
|
|
|
pwi->nd.cbOld = 0;
|
|
pwi->nd.fRespondedToWillEcho = FALSE;
|
|
pwi->nd.fRespondedToWillSGA = FALSE;
|
|
pwi->nd.fRespondedToDoAUTH = FALSE;
|
|
pwi->nd.fRespondedToDoNAWS = FALSE;
|
|
|
|
//we are making sure that we always have VT100 arrow key support
|
|
ClearVTArrow(&pwi->trm);
|
|
|
|
//
|
|
// (a-roopb) We set these in GetUserSettings()
|
|
//ui.fDebug &= ~(fdwVT52Mode|fdwVT80Mode);
|
|
//ClearVT80(&gwi.trm);
|
|
//ClearKanjiStatus(&gwi.trm, CLEAR_ALL);
|
|
//ClearKanjiFlag(&gwi.trm);
|
|
//SetupCharSet(&gwi.trm);
|
|
//
|
|
|
|
#if 0
|
|
|
|
if (FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80))
|
|
{
|
|
|
|
if (ui.fDebug & fdwVT80Mode)
|
|
{
|
|
DWORD iMode = (ui.fDebug & fdwKanjiModeMask);
|
|
INT i;
|
|
|
|
SetVT80(&pwi->trm);
|
|
|
|
/* set current selection */
|
|
for(i=0 ; i<NUMBER_OF_KANJI ; i++)
|
|
{
|
|
if(iMode == KanjiList[i].KanjiID) {
|
|
SetKanjiMode(&pwi->trm,KanjiList[i].KanjiEmulationID);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(i == NUMBER_OF_KANJI ) {
|
|
/* set default */
|
|
SetSJISKanji(&pwi->trm);
|
|
ui.fDebug &= ~fdwKanjiModeMask;
|
|
ui.fDebug |= fdwSJISKanjiMode;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ClearKanjiFlag(&pwi->trm);
|
|
ClearVT80(&pwi->trm);
|
|
}
|
|
}
|
|
|
|
if (ui.fDebug & fdwVT100CursorKeys)
|
|
{
|
|
ClearVTArrow(&pwi->trm);
|
|
}
|
|
else
|
|
{
|
|
SetVTArrow(&pwi->trm);
|
|
}
|
|
|
|
/* Append the most recently connected machines to the Machine menu */
|
|
hmenu = HmenuGetMRUMenu(hwnd, &ui);
|
|
|
|
if (ui.cMachines > 0) {
|
|
AppendMenu(hmenu, MF_SEPARATOR, 0, 0);
|
|
}
|
|
|
|
for (i=0; i<ui.cMachines; ++i)
|
|
{
|
|
wsprintf(pchNBBuffer, szMachineMenuItem, (short)(i+1),
|
|
(BYTE *)(ui.rgchMachine[i]));
|
|
AppendMenu(hmenu, (UINT)(MF_ENABLED | MF_STRING), (UINT)(IDM_MACHINE1+i),
|
|
(LPCSTR)pchNBBuffer);
|
|
}
|
|
|
|
/* Disable maximizing or resizing the main window */
|
|
hmenu = GetSystemMenu(hwnd, FALSE);
|
|
|
|
// EnableMenuItem(hmenu, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
|
|
// EnableMenuItem(hmenu, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
|
|
|
|
DrawMenuBar( hwnd );
|
|
|
|
#endif
|
|
|
|
fInited = TRUE;
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
if (pwi->ichTelXfer != 0)
|
|
{
|
|
if (!FTelXferEnd(pwi, SV_DISCONNECT))
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
if (pwi != NULL)
|
|
{
|
|
if (pwi->trm.uTimer != 0)
|
|
{
|
|
KillTimer(hwnd, uTerminalTimerID);
|
|
pwi->trm.uTimer = 0;
|
|
}
|
|
|
|
if (pwi->ichTelXfer != 0)
|
|
{
|
|
(void)FTelXferEnd(pwi, SV_QUIT);
|
|
}
|
|
|
|
/*
|
|
* If in session then cancel current transmission and
|
|
* hangup on the host, close shop and head out of town...
|
|
*/
|
|
|
|
if (fInited == TRUE)
|
|
{
|
|
SetUserSettings(&ui);
|
|
FCloseConnection(hwnd);
|
|
}
|
|
}
|
|
|
|
SetWindowLong(hwnd, WL_TelWI, 0L);
|
|
|
|
if( FGetCodeMode(eCodeModeIMEFarEast) )
|
|
{
|
|
if ( ui.fDebug & fdwKanjiModeMask )
|
|
{
|
|
//
|
|
// Release input context.
|
|
//
|
|
ImmReleaseContext(hwnd,hImeContext);
|
|
}
|
|
}
|
|
|
|
break;
|
|
#if 0
|
|
case NN_HOSTRESOLVED:
|
|
if ( WSAGETASYNCERROR(lParam) == 0 )
|
|
pwi->nd.host = (struct hostent *)pwi->nd.szResolvedHost;
|
|
else
|
|
{
|
|
g_dwSockErr = WSAGETASYNCERROR(lParam);
|
|
}
|
|
|
|
SetEvent( g_hAsyncGetHostByNameEvent );
|
|
break;
|
|
#endif
|
|
case NN_LOST: /* Connection Lost */
|
|
|
|
DEBUG_PRINT(("NN_LOST received\n"));
|
|
|
|
if (fConnected && !fHungUp)
|
|
{
|
|
DWORD dwNumWritten;
|
|
WriteConsole(pwi->hOutput, szConnectionLost, _tcslen(szConnectionLost), &dwNumWritten, NULL);
|
|
}
|
|
|
|
/*
|
|
* If a connection attempt is made when we already have a
|
|
* connection, we hang up the connection and then attempt
|
|
* to connect to the desired machine. A side effect of the
|
|
* hang up of the previous connection is that we get a
|
|
* NN_LOST notification. So after a
|
|
* connection-hangup-connection, we ignore the first NN_LOST
|
|
* notification.
|
|
*/
|
|
if ( fHungUp )
|
|
{
|
|
fHungUp = FALSE;
|
|
break;
|
|
}
|
|
|
|
if( fClientLaunchedFromCommandPrompt )
|
|
{
|
|
g_lExitTelnet++;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwWritten;
|
|
INPUT_RECORD iRec;
|
|
TCHAR wcChar;
|
|
TCHAR szContinue[ MAX_STRING_LENGTH ];
|
|
|
|
LoadString(ghInstance, IDS_CONTINUE, szContinue,
|
|
sizeof(szContinue)/sizeof(TCHAR) );
|
|
|
|
SetConsoleActiveScreenBuffer( g_hSessionConsoleBuffer );
|
|
WriteConsole(g_hSessionConsoleBuffer, szContinue,
|
|
_tcslen(szContinue), &dwWritten, NULL);
|
|
ReadConsole(pwi->hInput, &wcChar, 1, &dwWritten, NULL );
|
|
SetConsoleActiveScreenBuffer( g_hTelnetPromptConsoleBuffer );
|
|
/*
|
|
We had connection and it broke off. Our ReadConsoleInput is stuck.
|
|
we need to wake it up by writing something to Console Input.
|
|
*/
|
|
{
|
|
iRec.EventType = FOCUS_EVENT;
|
|
WriteConsoleInput(pwi->hInput, &iRec, 1, &dwWritten );
|
|
}
|
|
|
|
CloseTelnetSession( NULL );
|
|
}
|
|
|
|
if (pwi->ichTelXfer != 0)
|
|
{
|
|
(void)FTelXferEnd(pwi, SV_HANGUP);
|
|
}
|
|
fConnected = FHangupConnection(pwi, &pwi->nd);
|
|
DoTermReset(pwi, &pwi->trm);
|
|
//when the term name is given after -t without
|
|
//any spaces. 2 accounts for -t.
|
|
|
|
pwi->nd.cbOld = 0;
|
|
pwi->nd.fRespondedToWillEcho = FALSE;
|
|
pwi->nd.fRespondedToWillSGA = FALSE;
|
|
pwi->nd.fRespondedToDoAUTH = FALSE;
|
|
pwi->nd.fRespondedToDoNAWS = FALSE;
|
|
pwi->nd.hsd = INVALID_SOCKET;
|
|
|
|
break;
|
|
|
|
#ifdef USETCP
|
|
case WS_ASYNC_SELECT:
|
|
#ifdef TCPTEST
|
|
snprintf(DebugBuffer,sizeof(DebugBuffer)-1, "WS_ASYNC_SELECT(%d) received\n",
|
|
WSAGETSELECTEVENT(lParam));
|
|
OutputDebugString(DebugBuffer);
|
|
#endif
|
|
|
|
switch (WSAGETSELECTEVENT(lParam)) {
|
|
case FD_READ:
|
|
DEBUG_PRINT(("FD_READ received\n"));
|
|
|
|
FProcessFDRead(hwnd);
|
|
break;
|
|
|
|
case FD_WRITE:
|
|
DEBUG_PRINT(( "FD_WRITE received\n" ));
|
|
|
|
//FProcessFDWrite(hwnd);
|
|
break;
|
|
|
|
case FD_CLOSE:
|
|
DEBUG_PRINT(("FD_CLOSE received\n"));
|
|
|
|
(void)PostMessage((HWND)hwnd, (UINT)NN_LOST, (WPARAM)0, (LPARAM)(void FAR *)hwnd);
|
|
break;
|
|
|
|
case FD_OOB:
|
|
DEBUG_PRINT(("FD_OOB received\n"));
|
|
|
|
FProcessFDOOB(hwnd);
|
|
break;
|
|
}
|
|
|
|
#endif
|
|
|
|
default: /* Passes it on if unprocessed */
|
|
// defresp:
|
|
|
|
// DEBUG_PRINT(( "<-- MainWndProc()\n" ));
|
|
return (DefWindowProc(hwnd, message, wParam, lParam));
|
|
}
|
|
|
|
|
|
DEBUG_PRINT(( "<-- MainWndProc() returning 0.\n" ));
|
|
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
GetUserSettings(UI *pui)
|
|
{
|
|
LONG lErr;
|
|
HKEY hkey = 0;
|
|
DWORD dwType;
|
|
DWORD dwDisp = 0;
|
|
TCHAR rgchValue[48];
|
|
LCID lcid;
|
|
DWORD dwMode = ( DWORD )-1;
|
|
DWORD dwSize = 0;
|
|
TCHAR szTlntMode[ SMALL_STRING+1 ];
|
|
BOOL bResetVT80 = TRUE;
|
|
DWORD dwStatus = 0;
|
|
|
|
lcid = GetThreadLocale();
|
|
|
|
lErr = RegCreateKeyEx(HKEY_CURRENT_USER,TEXT("Software\\Microsoft\\Telnet"),
|
|
0, NULL, REG_OPTION_NON_VOLATILE,
|
|
KEY_QUERY_VALUE | KEY_SET_VALUE,
|
|
NULL, &hkey, &dwDisp);
|
|
|
|
if (lErr != ERROR_SUCCESS)
|
|
{
|
|
if ( FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80))
|
|
gwi.trm.puchCharSet = rgchCharSetWorkArea;
|
|
return;
|
|
}
|
|
|
|
dwDisp = sizeof(gwi.trm.RequestedTermType);
|
|
if( ERROR_SUCCESS != (RegQueryValueEx(hkey, TEXT("TERMTYPE"), NULL, &dwType,
|
|
(LPBYTE)&gwi.trm.RequestedTermType, &dwDisp)))
|
|
{
|
|
gwi.trm.RequestedTermType = TT_ANSI;
|
|
}
|
|
|
|
dwDisp = sizeof(DWORD);
|
|
if( ERROR_SUCCESS != (RegQueryValueEx(hkey,TEXT("NTLM"), NULL, &dwType,
|
|
(LPBYTE)&ui.bWillAUTH, &dwDisp)))
|
|
{
|
|
ui.bWillAUTH = TRUE;
|
|
}
|
|
|
|
/* Get the value of the left size of the Window */
|
|
LoadString(ghInstance, IDS_DEBUGFLAGS, rgchValue, sizeof(rgchValue)/sizeof(TCHAR));
|
|
dwDisp = sizeof(pui->fDebug);
|
|
if ( FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80))
|
|
{
|
|
if( ERROR_SUCCESS != RegQueryValueEx(hkey, rgchValue, NULL, &dwType,
|
|
(LPBYTE)&pui->fDebug, &dwDisp))
|
|
{
|
|
/* default is VT80/Kanji and Shift-Jis mode */
|
|
|
|
pui->fDebug |= (fdwVT80Mode | fdwSJISKanjiMode);
|
|
}
|
|
}
|
|
else
|
|
(void)RegQueryValueEx(hkey, rgchValue, NULL, &dwType,
|
|
(LPBYTE)&pui->fDebug, &dwDisp);
|
|
|
|
|
|
LoadString(ghInstance, IDS_PROMPTFLAGS, rgchValue, sizeof(rgchValue)/sizeof(TCHAR));
|
|
dwDisp = sizeof(pui->fPrompt);
|
|
(void)RegQueryValueEx(hkey, rgchValue, NULL, &dwType,
|
|
(LPBYTE)&pui->fPrompt, &dwDisp);
|
|
|
|
dwDisp = sizeof(BOOL);
|
|
if( ERROR_SUCCESS != (RegQueryValueEx(hkey, TEXT("BSASDEL"), 0, &dwType,
|
|
(LPBYTE)&g_bSendBackSpaceAsDel, &dwDisp )))
|
|
{
|
|
g_bSendBackSpaceAsDel = 0;
|
|
}
|
|
|
|
dwDisp = sizeof(BOOL);
|
|
if( ERROR_SUCCESS != (RegQueryValueEx(hkey, TEXT("DELASBS"), 0, &dwType,
|
|
(LPBYTE)&g_bSendDelAsBackSpace, &dwDisp )))
|
|
{
|
|
g_bSendDelAsBackSpace = 0;
|
|
}
|
|
|
|
dwDisp = sizeof( ui.dwCrLf );
|
|
if( ERROR_SUCCESS != (RegQueryValueEx(hkey, TEXT("CRLF"), 0, &dwType, (LPBYTE)&ui.dwCrLf, &dwDisp )))
|
|
{
|
|
/*++
|
|
The most significant bit in ui.fDebug ( read from HKCU\Software\Microsoft\telnet\DebugFlags)
|
|
corresponds to CRLF setting on w2k. If this bit is 1, then the client sends only CR.
|
|
If this bit is 0, client sends both CR,LF. When we don't find CRLF value
|
|
in HKCU\Software\Microsoft\telnet, that could mean two things
|
|
1. User has upgraded from w2k : In this case, we should check whether the user had
|
|
changed CRLF setting and honor that setting. So if MSBit of ui.fDebug is 1, setting is CR
|
|
else it's CR & LF.
|
|
2. Fresh whistler installation : In this case, MSBit of fDebug will be 0
|
|
so the client will send CR & LF, which is the default.
|
|
--*/
|
|
if(ui.fDebug & fdwOnlyCR)
|
|
{
|
|
ui.dwCrLf = FALSE;
|
|
ClearLineMode( &( gwi.trm ) );
|
|
}
|
|
else //this means that we upgraded from w2k and CRLF was set on w2k so preserve
|
|
{
|
|
ui.dwCrLf = TRUE;
|
|
SetLineMode( &( gwi.trm ) );
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
ui.dwCrLf ? SetLineMode(&( gwi.trm )): ClearLineMode(&(gwi.trm));
|
|
}
|
|
dwDisp = MAX_PATH + 1;
|
|
dwStatus = RegQueryValueEx(hkey, TEXT("MODE"), 0, &dwType, (LPBYTE)szTlntMode, &dwDisp );
|
|
if( _tcsicmp( szTlntMode, L"Stream" ) != 0 && _tcsicmp( szTlntMode, L"Console" ) != 0)
|
|
{
|
|
_tcscpy( szTlntMode, L"Console" );//no overflow. Source string is const wchar *.
|
|
}
|
|
SetEnvironmentVariable( TEXT( SFUTLNTMODE ), szTlntMode );
|
|
|
|
|
|
if ( FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80))
|
|
{
|
|
// Bug Emulation in VT100/Kanji(VT80)
|
|
// Abnormal AP is mh-e6.2 for PC-UX.
|
|
LoadString(ghInstance, IDS_BUGEMUFLAGS, rgchValue, sizeof(rgchValue)/sizeof(TCHAR));
|
|
dwDisp = sizeof(pui->fBugEmulation);
|
|
if( ERROR_SUCCESS != RegQueryValueEx(hkey, rgchValue, NULL, &dwType,
|
|
(LPBYTE)&pui->fBugEmulation, &dwDisp))
|
|
{
|
|
/* default is non Emulation */
|
|
pui->fBugEmulation = (DWORD)0;
|
|
}
|
|
|
|
// ACOS-KANJI Support Flga
|
|
LoadString(ghInstance, IDS_ACOSFLAG, rgchValue, sizeof(rgchValue)/sizeof(TCHAR));
|
|
dwDisp = sizeof(pui->fAcosSupportFlag);
|
|
if( ERROR_SUCCESS != RegQueryValueEx(hkey, rgchValue, NULL, &dwType,
|
|
(LPBYTE)&pui->fAcosSupportFlag, &dwDisp
|
|
)) {
|
|
/* Set default support */
|
|
#if defined(_X86_)
|
|
/* if NEC_98 */
|
|
if (( FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80)) &&
|
|
(HIBYTE(LOWORD(GetKeyboardType(1))) == 0x0D))
|
|
pui->fAcosSupportFlag = fAcosSupport;
|
|
else
|
|
#endif // defined(_X86_)
|
|
pui->fAcosSupportFlag = (DWORD)0;
|
|
}
|
|
if ( !(pui->fAcosSupportFlag & fAcosSupport)
|
|
&& ((fdwVT80Mode | fdwACOSKanjiMode) == (pui->fDebug & (fdwVT80Mode |
|
|
fdwACOSKanjiMode))) ) {
|
|
pui->fDebug &= ~(fdwVT80Mode | fdwACOSKanjiMode);
|
|
pui->fDebug |= (fdwVT80Mode | fdwSJISKanjiMode);
|
|
}
|
|
|
|
if( (GetACP() == JAP_CODEPAGE ) && ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("CODESET"), NULL, &dwType,
|
|
(LPBYTE)&dwMode, &dwDisp))
|
|
{
|
|
if( (LONG)dwMode >= 0 )
|
|
{
|
|
int i;
|
|
|
|
for( i=0 ; i<NUMBER_OF_KANJI ; ++i )
|
|
{
|
|
if( dwMode == KanjiList[i].KanjiID )
|
|
{
|
|
bResetVT80 = FALSE;
|
|
SetVT80(&gwi.trm);
|
|
ui.fDebug &= ~fdwKanjiModeMask;
|
|
ClearKanjiFlag(&gwi.trm);
|
|
ui.fDebug |= KanjiList[i].KanjiID;
|
|
ui.fDebug |= fdwVT80Mode;
|
|
SetKanjiMode(&gwi.trm,KanjiList[i].KanjiEmulationID);
|
|
gwi.trm.puchCharSet = rgchCharSetWorkArea;
|
|
SetupCharSet(&gwi.trm);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( bResetVT80 )
|
|
{
|
|
ui.fDebug &= ~(fdwVT52Mode|fdwVT80Mode);
|
|
ui.fDebug &= ~(fdwKanjiModeMask);
|
|
ClearVT80(&gwi.trm);
|
|
ClearKanjiStatus(&gwi.trm, CLEAR_ALL);
|
|
ClearKanjiFlag(&gwi.trm);
|
|
gwi.trm.puchCharSet = rgchCharSetWorkArea;
|
|
SetupCharSet(&gwi.trm);
|
|
}
|
|
|
|
}
|
|
RegCloseKey( hkey );
|
|
}
|
|
|
|
|
|
void
|
|
SetUserSettings(UI *pui)
|
|
{
|
|
LONG lErr;
|
|
HKEY hkey = 0;
|
|
TCHAR rgchValue[48];
|
|
LCID lcid;
|
|
DWORD dwMode = ( DWORD )-1;
|
|
DWORD dwSize = 0;
|
|
TCHAR szTlntMode[ SMALL_STRING+1 ];
|
|
|
|
lcid = GetThreadLocale();
|
|
|
|
|
|
lErr = RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Telnet"),
|
|
0, KEY_SET_VALUE, &hkey);
|
|
|
|
if (lErr != ERROR_SUCCESS)
|
|
{
|
|
return;
|
|
}
|
|
|
|
#ifdef TCPTEST
|
|
snprintf(DebugBuffer, sizeof(DebugBuffer)-1,"End pui -> text = %lx, back = %lx\n",
|
|
pui->clrText, pui->clrBk);
|
|
OutputDebugString(DebugBuffer);
|
|
#endif
|
|
|
|
RegSetValueEx(hkey, TEXT("TERMTYPE"), 0, REG_DWORD,
|
|
(LPBYTE)&gwi.trm.RequestedTermType, sizeof(DWORD));
|
|
|
|
RegSetValueEx(hkey, TEXT("NTLM"), 0, REG_DWORD,
|
|
(LPBYTE)&ui.bWillAUTH, sizeof(DWORD));
|
|
|
|
//Make localecho non-sticky.
|
|
pui->fDebug &= ~fdwLocalEcho;
|
|
|
|
LoadString(ghInstance, IDS_DEBUGFLAGS, rgchValue, sizeof(rgchValue)/sizeof(TCHAR));
|
|
(void)RegSetValueEx(hkey, rgchValue, 0, REG_DWORD,
|
|
(LPBYTE)&pui->fDebug, sizeof(DWORD));
|
|
|
|
LoadString(ghInstance, IDS_PROMPTFLAGS, rgchValue, sizeof(rgchValue)/sizeof(TCHAR));
|
|
(void)RegSetValueEx(hkey, rgchValue, 0, REG_DWORD,
|
|
(LPBYTE)&pui->fPrompt, sizeof(DWORD));
|
|
|
|
RegSetValueEx(hkey, TEXT("BSASDEL"), 0, REG_DWORD,
|
|
(LPBYTE)&g_bSendBackSpaceAsDel, sizeof(DWORD));
|
|
RegSetValueEx(hkey, TEXT("DELASBS"), 0, REG_DWORD,
|
|
(LPBYTE)&g_bSendDelAsBackSpace, sizeof(DWORD));
|
|
|
|
RegSetValueEx(hkey, ( LPTSTR )TEXT("CRLF"), 0, REG_DWORD, (LPBYTE)&ui.dwCrLf, sizeof(DWORD));
|
|
|
|
dwSize = GetEnvironmentVariable( TEXT( SFUTLNTMODE ), szTlntMode, SMALL_STRING+1 );
|
|
if( dwSize <= 0 )
|
|
{
|
|
wcscpy( szTlntMode, L"Console" );//no overflow. Source string is const wchar *.
|
|
}
|
|
dwSize = 2 * wcslen( szTlntMode );
|
|
RegSetValueEx(hkey,TEXT("MODE"), 0, REG_SZ, (LPBYTE)szTlntMode, dwSize );
|
|
|
|
|
|
if ( (GetACP() == JAP_CODEPAGE ) && FGetCodeMode(eCodeModeFarEast) && FGetCodeMode(eCodeModeVT80))
|
|
{
|
|
// Bug Emulation in VT100/Kanji(VT80)
|
|
// Abnormal AP is mh-e6.2 for PC-UX.
|
|
LoadString(ghInstance, IDS_BUGEMUFLAGS, rgchValue, sizeof(rgchValue)/sizeof(TCHAR));
|
|
(void)RegSetValueEx(hkey, rgchValue, 0, REG_DWORD,
|
|
(LPBYTE)&pui->fBugEmulation, sizeof(DWORD));
|
|
|
|
// ACOS-KANJI Support Flga
|
|
LoadString(ghInstance, IDS_ACOSFLAG, rgchValue, sizeof(rgchValue)/sizeof(TCHAR));
|
|
(void)RegSetValueEx(hkey, rgchValue, 0, REG_DWORD,
|
|
(LPBYTE)&pui->fAcosSupportFlag, sizeof(DWORD));
|
|
|
|
if ( ui.fDebug & fdwKanjiModeMask )
|
|
{
|
|
dwMode = ui.fDebug & fdwKanjiModeMask;
|
|
}
|
|
|
|
(void)RegSetValueEx(hkey, TEXT("CODESET"), 0, REG_DWORD, (LPBYTE)&dwMode, sizeof(DWORD));
|
|
}
|
|
|
|
|
|
RegCloseKey( hkey );
|
|
}
|
|
|
|
/*
|
|
Description:
|
|
|
|
Set SO_EXCLUSIVEADDRUSE on a socket.
|
|
Parameters:
|
|
|
|
[in] socket
|
|
Return Values: On error, returns SOCKET_ERROR.
|
|
*/
|
|
int SafeSetSocketOptions(SOCKET s)
|
|
{
|
|
int iStatus;
|
|
int iSet = 1;
|
|
iStatus = setsockopt( s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE , ( char* ) &iSet,
|
|
sizeof( iSet ) );
|
|
return ( iStatus );
|
|
}
|
|
|
|
void
|
|
ErrorMessage(LPCTSTR pStr1, LPCTSTR pStr2)
|
|
{
|
|
DWORD dwWritten;
|
|
|
|
WriteConsole(gwi.hOutput, pStr1, _tcslen(pStr1), &dwWritten, NULL);
|
|
WriteConsole(gwi.hOutput, ( LPTSTR )TEXT(": "), _tcslen( ( LPTSTR )TEXT(": ")), &dwWritten, NULL);
|
|
WriteConsole(gwi.hOutput, pStr2, _tcslen(pStr2), &dwWritten, NULL);
|
|
WriteConsole(gwi.hOutput, ( LPTSTR )TEXT("\n"), _tcslen( ( LPTSTR )TEXT("\n")), &dwWritten, NULL);
|
|
}
|
|
|
|
void ConnectTimeErrorMessage(LPCTSTR pStr1, LPCTSTR pStr2)
|
|
{
|
|
DWORD dwWritten;
|
|
|
|
WriteConsole(gwi.hOutput, pStr1, _tcslen(pStr1), &dwWritten, NULL);
|
|
WriteConsole(gwi.hOutput, ( LPTSTR )TEXT("."), _tcslen( ( LPTSTR )TEXT(".")), &dwWritten, NULL);
|
|
WriteConsole(gwi.hOutput, ( LPTSTR )TEXT("\n"), _tcslen( ( LPTSTR )TEXT("\n")), &dwWritten, NULL);
|
|
WriteConsole(gwi.hOutput, pStr2, _tcslen(pStr2), &dwWritten, NULL);
|
|
WriteConsole(gwi.hOutput, ( LPTSTR )TEXT("\n"), _tcslen( ( LPTSTR )TEXT("\n")), &dwWritten, NULL);
|
|
}
|