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.
2033 lines
60 KiB
2033 lines
60 KiB
//Copyright (c) Microsoft Corporation. All rights reserved.
|
|
/****************************************************************************
|
|
|
|
FILE: NetIO.c
|
|
|
|
Functions for connecting to machines and handling data transfers
|
|
between machines.
|
|
|
|
TABS:
|
|
|
|
Set for 4 spaces.
|
|
|
|
****************************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <windows.h> // required for all Windows applications
|
|
#include <lmcons.h>
|
|
#include <tchar.h>
|
|
#pragma warning (disable: 4201) // disable "nonstandard extension used : nameless struct/union"
|
|
#include <commdlg.h>
|
|
#pragma warning (default: 4201)
|
|
#include <stdlib.h>
|
|
#include "WinTel.h" // specific to this program
|
|
#include "commands.h"
|
|
#include "debug.h"
|
|
|
|
#pragma warning( disable : 4100 )
|
|
#ifdef USETCP
|
|
#include "telnet.h"
|
|
#endif
|
|
|
|
char *rgchTermType[] = { "ANSI", "VT100", "VT52", "VTNT" };
|
|
|
|
extern void NTLMCleanup();
|
|
extern BOOL DoNTLMAuth(WI *pwi, PUCHAR pBuffer, DWORD dwSize);
|
|
extern int SafeSetSocketOptions(SOCKET s);
|
|
|
|
BOOL g_fSentWillNaws = FALSE;
|
|
static BOOL FAttemptServerConnect(WI *pwi, LPSTR, LPNETDATA);
|
|
static void xfGetData(char, char *, DWORD, int);
|
|
#ifdef USETCP
|
|
#ifdef TELXFER
|
|
static DWORD xfGetSomeData(char *, DWORD, int);
|
|
#endif //TELXFER
|
|
#endif //USETCP
|
|
|
|
static void xfPutc(char, int);
|
|
|
|
static int term_inx = 0;
|
|
|
|
extern BOOL StartNTLMAuth(WI *);
|
|
extern TCHAR szUserName[ UNLEN + 1 ];
|
|
extern CHAR* szUser;
|
|
|
|
TCHAR szCombinedFailMsg [255];
|
|
|
|
extern HANDLE g_hControlHandlerEvent;
|
|
extern HANDLE g_hCaptureConsoleEvent;
|
|
extern HANDLE g_hAsyncGetHostByNameEvent;
|
|
extern HANDLE g_hRemoteNEscapeModeDataSync;
|
|
extern BOOL g_fConnectFailed;
|
|
|
|
void
|
|
GetErrMsgString( DWORD dwErrNum, LPTSTR *lpBuffer )
|
|
{
|
|
DWORD dwStatus = 0;
|
|
LCID old_thread_locale;
|
|
|
|
switch (GetACP())
|
|
{
|
|
// for Hebrew and arabic winerror.h is not localized..so get the english one for all these
|
|
case 1256:
|
|
case 1255:
|
|
|
|
old_thread_locale = GetThreadLocale();
|
|
|
|
SetThreadLocale(
|
|
MAKELCID(
|
|
MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
|
|
SORT_DEFAULT
|
|
)
|
|
);
|
|
break;
|
|
|
|
default:
|
|
old_thread_locale = -1;
|
|
|
|
}
|
|
|
|
dwStatus = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
NULL, dwErrNum, LANG_NEUTRAL, ( LPTSTR )lpBuffer, 0, NULL );
|
|
|
|
if( !dwStatus )
|
|
{
|
|
*lpBuffer = NULL;
|
|
}
|
|
|
|
if (old_thread_locale != -1)
|
|
{
|
|
SetThreadLocale(old_thread_locale);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
BOOL
|
|
FConnectToServer(WI *pwi, LPSTR szHostName, LPNETDATA lpData)
|
|
{
|
|
BOOL fResult;
|
|
|
|
// Before we Connect we make sure we are not connected.
|
|
// This ASSERT should never blowup !!
|
|
ASSERT(fConnected==FALSE);
|
|
|
|
// We initialize stuff for this connection.
|
|
pwi->trm.SentTermType = TT_UNKNOWN;
|
|
pwi->trm.CurrentTermType = TT_ANSI; /* this is our default term type*/
|
|
|
|
fResult = FAttemptServerConnect(pwi, szHostName, lpData);
|
|
|
|
if( fResult != TRUE )
|
|
{
|
|
TCHAR szStr[ cchMaxHostName ];
|
|
g_fConnectFailed = TRUE;
|
|
|
|
if( g_szPortNameOrNo[ 0 ] == 0 )
|
|
{
|
|
_sntprintf( g_szPortNameOrNo,cchMaxHostName-1,( LPCTSTR )L"%d", rgService );
|
|
}
|
|
|
|
_sntprintf( szStr, cchMaxHostName -1 ,szOnPort, g_szPortNameOrNo );
|
|
_sntprintf(szCombinedFailMsg,ARRAY_SIZE(szCombinedFailMsg)-1,_T("%s%s"),szConnectFailedMsg,szStr);
|
|
|
|
g_szPortNameOrNo[ 0 ] = 0;
|
|
|
|
if( g_dwSockErr == 0 )
|
|
{
|
|
//Not an error we want to inform abt
|
|
ErrorMessage( szCombinedFailMsg, szConnectFailed );
|
|
}
|
|
else
|
|
{
|
|
DWORD dwWritten = 0;
|
|
LPTSTR lpBuffer = NULL;
|
|
|
|
GetErrMsgString( g_dwSockErr, &lpBuffer );
|
|
if( lpBuffer )
|
|
{
|
|
ConnectTimeErrorMessage( szCombinedFailMsg, lpBuffer );
|
|
LocalFree( lpBuffer );
|
|
}
|
|
else
|
|
{
|
|
ErrorMessage( szCombinedFailMsg, szConnectFailed );
|
|
}
|
|
}
|
|
}
|
|
|
|
return fResult;
|
|
}
|
|
|
|
#ifdef USETCP
|
|
|
|
/*** FPostReceive - post an asynchronous receive
|
|
*/
|
|
BOOL
|
|
FPostReceive(LPNETDATA lpData)
|
|
{
|
|
|
|
#ifdef NBTEST
|
|
OutputDebugString("PostReceive In\n");
|
|
#endif
|
|
|
|
#ifdef NBTEST
|
|
OutputDebugString("PostReceive Out\n");
|
|
#endif
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
FWriteToNet(WI *pwi, LPSTR addr, int cnt)
|
|
{
|
|
|
|
int len = 0, retries = 0;
|
|
if(pwi->nd.hsd == INVALID_SOCKET)
|
|
{
|
|
len = SOCKET_ERROR;
|
|
goto Done;
|
|
}
|
|
do
|
|
{
|
|
len = send( pwi->nd.hsd, addr, cnt, 0 );
|
|
retries ++;
|
|
}
|
|
while ((len == SOCKET_ERROR) && (WSAGetLastError() == WSAEWOULDBLOCK) && (retries < 5));
|
|
Done:
|
|
return(len);
|
|
}
|
|
|
|
BOOL
|
|
FCommandPending(WI *pwi)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
/*
|
|
|
|
void
|
|
FSendTM( HWND hwnd )
|
|
{
|
|
WI *pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
unsigned char sbuf[] = { IAC, DO, TO_TM };
|
|
|
|
ui.fFlushOut = 1;
|
|
send( pwi->nd.hsd, ( char * )sbuf, sizeof( sbuf ), 0);
|
|
}
|
|
*/
|
|
|
|
//Our server still doesn't support urgent data handling..
|
|
void
|
|
FSendSynch(HWND hwnd)
|
|
{
|
|
WI *pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
unsigned char sbuf[] = { IAC, DM };
|
|
|
|
send( pwi->nd.hsd, ( char * )sbuf, 1, 0 );
|
|
|
|
send( pwi->nd.hsd, ( char * )( sbuf + 1 ), 1, MSG_OOB );
|
|
}
|
|
|
|
void
|
|
FSendTelnetCommands( HWND hwnd, char chCommand )
|
|
{
|
|
WI *pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
unsigned char sbuf[]={ IAC , 0 };
|
|
|
|
sbuf[1] = chCommand;
|
|
|
|
send( pwi->nd.hsd, ( char * )sbuf, sizeof( sbuf ), 0 );
|
|
}
|
|
|
|
void
|
|
FSendChars(HWND hwnd, WCHAR rgchChar[], int iLength )
|
|
{
|
|
WI *pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
CHAR rgchMBChar[ SMALL_STRING ];
|
|
|
|
iLength = WideCharToMultiByte( GetConsoleCP(), 0, rgchChar, iLength,
|
|
rgchMBChar, (SMALL_STRING - sizeof(CHAR)), NULL, NULL );
|
|
|
|
send( pwi->nd.hsd, rgchMBChar, iLength, 0 );
|
|
}
|
|
|
|
|
|
void
|
|
FDisableFlush(HWND hwnd)
|
|
{
|
|
WI *pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
|
|
if (ui.fFlushOut) {
|
|
ui.fFlushOut = 0;
|
|
DoIBMANSIOutput(pwi, &pwi->trm, strlen( ( CHAR * ) szNewLine), szNewLine);
|
|
#ifdef TCPTEST
|
|
OutputDebugString("Disable Flush\n");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void
|
|
FProcessDont(WI *pwi, LPSTR *ps)
|
|
{
|
|
unsigned char sbuf[16];
|
|
|
|
sbuf[0] = IAC;
|
|
sbuf[1] = WONT;
|
|
|
|
switch (*(unsigned char FAR *)(*ps)) {
|
|
|
|
default:
|
|
sbuf[2] = *(unsigned char FAR *)(*ps);
|
|
break;
|
|
}
|
|
|
|
FWriteToNet(pwi, ( char* )sbuf, 3);
|
|
|
|
if( *(*ps) == TO_NAWS )
|
|
{
|
|
g_bDontNAWSReceived = TRUE;
|
|
}
|
|
}
|
|
|
|
void DoNawsSubNegotiation( WI *pwi )
|
|
{
|
|
unsigned char sbuf[16];
|
|
INT iIndex = 0;
|
|
|
|
sbuf[iIndex++] = IAC;
|
|
sbuf[iIndex++] = SB;
|
|
sbuf[iIndex++] = TO_NAWS;
|
|
sbuf[iIndex++] = 0;
|
|
sbuf[iIndex++] = ( UCHAR ) ( (pwi->sbi.srWindow.Right - pwi->sbi.srWindow.Left) + 1 ) ;
|
|
sbuf[iIndex++] = 0;
|
|
sbuf[iIndex++] = ( UCHAR )( ( pwi->sbi.srWindow.Bottom - pwi->sbi.srWindow.Top ) + 1 );
|
|
sbuf[iIndex++] = IAC;
|
|
sbuf[iIndex++] = SE;
|
|
|
|
FWriteToNet(pwi, ( char* )sbuf, iIndex );
|
|
}
|
|
|
|
void
|
|
FProcessDo(WI *pwi, LPSTR *ps)
|
|
{
|
|
unsigned char sbuf[16];
|
|
BOOL bWriteToNet = TRUE;
|
|
|
|
sbuf[0] = IAC;
|
|
sbuf[1] = WONT;
|
|
|
|
switch (*(unsigned char FAR *)(*ps)) {
|
|
case TO_NEW_ENVIRON:
|
|
sbuf[1] = WILL;
|
|
sbuf[2] = TO_NEW_ENVIRON;
|
|
break;
|
|
|
|
case TO_NAWS:
|
|
{
|
|
INT iIndex = 1;
|
|
|
|
if( !g_fSentWillNaws )
|
|
{
|
|
sbuf[iIndex++] = WILL;
|
|
sbuf[iIndex++] = TO_NAWS;
|
|
FWriteToNet(pwi, ( char* )sbuf, iIndex );
|
|
g_fSentWillNaws = TRUE;
|
|
}
|
|
|
|
DoNawsSubNegotiation( pwi );
|
|
pwi->nd.fRespondedToDoNAWS = TRUE;
|
|
bWriteToNet = FALSE;
|
|
}
|
|
break;
|
|
|
|
case TO_ECHO:
|
|
sbuf[1] = WILL;
|
|
sbuf[2] = TO_ECHO;
|
|
break;
|
|
|
|
case TO_BINARY:
|
|
sbuf[1] = WILL;
|
|
sbuf[2] = TO_BINARY;
|
|
break;
|
|
|
|
case TO_TERM_TYPE: /* terminal type */
|
|
sbuf[1] = WILL;
|
|
sbuf[2] = TO_TERM_TYPE;
|
|
|
|
|
|
if( !pwi->nd.fRespondedToDoNAWS && !g_fSentWillNaws )
|
|
{
|
|
sbuf[3] = IAC;
|
|
sbuf[4] = WILL;
|
|
sbuf[5] = TO_NAWS;
|
|
bWriteToNet = FALSE;
|
|
FWriteToNet(pwi, ( char* )sbuf, 6);
|
|
g_fSentWillNaws = TRUE;
|
|
}
|
|
|
|
// haven't sent the termtype over yet.
|
|
pwi->trm.SentTermType = TT_UNKNOWN;
|
|
break;
|
|
|
|
case TO_AUTH:
|
|
|
|
if( pwi->nd.fRespondedToDoAUTH )
|
|
return;
|
|
|
|
if( ui.bWillAUTH )
|
|
sbuf[1] = WILL;
|
|
sbuf[2] = TO_AUTH;
|
|
pwi->nd.fRespondedToDoAUTH = TRUE;
|
|
break;
|
|
|
|
case TO_SGA: // will SUPPRESS-GO-AHEAD
|
|
sbuf[1] = WILL;
|
|
sbuf[2] = TO_SGA;
|
|
|
|
break;
|
|
|
|
default:
|
|
sbuf[2] = *(unsigned char FAR *)(*ps);
|
|
break;
|
|
}
|
|
|
|
if ( bWriteToNet )
|
|
{
|
|
FWriteToNet(pwi, ( char* )sbuf, 3);
|
|
}
|
|
}
|
|
|
|
void
|
|
FProcessWont(WI *pwi, LPSTR *ps)
|
|
{
|
|
unsigned char sbuf[16];
|
|
|
|
sbuf[0] = IAC;
|
|
sbuf[1] = DONT;
|
|
|
|
switch (*(unsigned char FAR *)(*ps)) {
|
|
|
|
case TO_ECHO:
|
|
sbuf[2] = TO_ECHO;
|
|
break;
|
|
case TO_TERM_TYPE:
|
|
sbuf[2] = TO_TERM_TYPE;
|
|
break;
|
|
case TO_TM:
|
|
FDisableFlush(pwi->hwnd);
|
|
return;
|
|
default:
|
|
sbuf[2] = *(unsigned char FAR *)(*ps);
|
|
break;
|
|
}
|
|
FWriteToNet(pwi, ( char* )sbuf, 3);
|
|
}
|
|
|
|
void
|
|
FProcessWill(WI *pwi, LPSTR *ps)
|
|
{
|
|
unsigned char sbuf[16];
|
|
BOOL bWriteToNet = TRUE;
|
|
|
|
sbuf[0] = IAC;
|
|
sbuf[1] = DONT;
|
|
|
|
switch (*(unsigned char FAR *)(*ps)) {
|
|
|
|
case TO_ECHO:
|
|
|
|
if( pwi->nd.fRespondedToWillEcho )
|
|
return;
|
|
|
|
sbuf[1] = DO;
|
|
sbuf[2] = TO_ECHO;
|
|
pwi->nd.fRespondedToWillEcho = TRUE;
|
|
break;
|
|
|
|
case TO_TM:
|
|
FDisableFlush(pwi->hwnd);
|
|
return;
|
|
|
|
case TO_SGA:
|
|
|
|
if( pwi->nd.fRespondedToWillSGA )
|
|
return;
|
|
|
|
sbuf[1] = DO;
|
|
sbuf[2] = TO_SGA;
|
|
pwi->nd.fRespondedToWillSGA = TRUE;
|
|
break;
|
|
|
|
case TO_BINARY:
|
|
|
|
sbuf[1] = DO;
|
|
sbuf[2] = TO_BINARY;
|
|
|
|
break;
|
|
|
|
#if 0
|
|
case TO_NTLM:
|
|
|
|
if ( pwi->nd.fRespondedToWillNTLM )
|
|
return;
|
|
|
|
if ( ui.bDoNTLM )
|
|
sbuf[1] = DO;
|
|
sbuf[2] = TO_NTLM;
|
|
pwi->nd.fRespondedToWillNTLM = TRUE;
|
|
if ( ui.bDoNTLM )
|
|
{
|
|
bWriteToNet = FALSE;
|
|
FWriteToNet(pwi, sbuf, 3);
|
|
StartNTLMAuth(pwi);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
sbuf[2] = *(unsigned char FAR *)(*ps);
|
|
break;
|
|
}
|
|
if ( bWriteToNet )
|
|
FWriteToNet(pwi, ( char* )sbuf, 3);
|
|
}
|
|
|
|
|
|
|
|
BOOL StuffEscapeIACs( PUCHAR* ppBufDest, UCHAR bufSrc[], DWORD* pdwSize )
|
|
{
|
|
size_t length;
|
|
int cursorDest = 0;
|
|
int cursorSrc = 0;
|
|
BOOL found = FALSE;
|
|
PUCHAR pDest = NULL;
|
|
|
|
if( *pdwSize <= 0 )
|
|
{
|
|
return ( found );
|
|
}
|
|
|
|
//get the location of the first occurrence of IAC
|
|
pDest = (PUCHAR) memchr( bufSrc, IAC, *pdwSize ); //attack? pdwsize could not be traced back to see if it's always valid.
|
|
|
|
if( pDest == NULL )
|
|
{
|
|
return ( found );
|
|
}
|
|
|
|
*ppBufDest = (PUCHAR) malloc( *pdwSize * 2 );
|
|
if( *ppBufDest == NULL )
|
|
{
|
|
ASSERT( ( 0, 0 ) );
|
|
return ( found );
|
|
}
|
|
|
|
while( pDest != NULL )
|
|
{
|
|
//copy data upto and including that point
|
|
length = (pDest - ( bufSrc + cursorSrc)) + 1 ;
|
|
memcpy( *ppBufDest + cursorDest, bufSrc + cursorSrc, length ); //attack? length could not be traced back to see if it's always valid.
|
|
cursorDest += length;
|
|
|
|
//stuff another TC_IAC
|
|
(*ppBufDest)[ cursorDest ] = IAC;
|
|
cursorDest++;
|
|
|
|
cursorSrc += length;
|
|
pDest = (PUCHAR) memchr( bufSrc + cursorSrc, IAC,
|
|
*pdwSize - cursorSrc ); //attack? pdwsize could not be traced back to see if it's always valid.
|
|
}
|
|
|
|
//copy remaining data
|
|
memcpy( *ppBufDest + cursorDest, bufSrc + cursorSrc,
|
|
*pdwSize - cursorSrc ); //attack? pdwsize could not be traced back to see if it's always valid.
|
|
|
|
|
|
if( cursorDest )
|
|
{
|
|
*pdwSize += cursorDest - cursorSrc;
|
|
found = TRUE;
|
|
}
|
|
|
|
return ( found );
|
|
}
|
|
|
|
INT GetVariable( UCHAR rgchBuffer[], CHAR szVar[] )
|
|
{
|
|
INT iIndex = 0;
|
|
INT iVarIndex = 0;
|
|
|
|
while( iIndex < MAX_BUFFER_SIZE && iVarIndex < MAX_STRING_LENGTH
|
|
&& rgchBuffer[ iIndex ] != VAR
|
|
&& rgchBuffer[ iIndex ] != USERVAR
|
|
&& ( !( rgchBuffer[ iIndex ] == IAC && rgchBuffer[ iIndex + 1 ] == SE ) )
|
|
)
|
|
{
|
|
if( rgchBuffer[ iIndex ] == ESC )
|
|
{
|
|
//ignore ESC and take the next char as part of name
|
|
iIndex++;
|
|
}
|
|
szVar[ iVarIndex++ ] = rgchBuffer[ iIndex++ ];
|
|
}
|
|
|
|
szVar[ iVarIndex ] = 0;
|
|
return iIndex;
|
|
}
|
|
|
|
|
|
void PutDefaultVarsInBuffer( UCHAR ucBuffer[], INT *iIndex )
|
|
{
|
|
ASSERT( iIndex );
|
|
|
|
if( wcscmp( szUserName, ( LPTSTR )L"" ) != 0 )
|
|
{
|
|
DWORD dwNum;
|
|
|
|
ASSERT( szUser );
|
|
|
|
if( *iIndex +
|
|
( strlen( USER ) + 1 ) +
|
|
( strlen( szUser ) + 1 ) +
|
|
( strlen( SYSTEMTYPE ) + 1 ) +
|
|
( strlen( WIN32_STRING ) + 1 ) > MAX_STRING_LENGTH )
|
|
{
|
|
ASSERT( 0 );
|
|
return;
|
|
}
|
|
|
|
{
|
|
//variable USER
|
|
ucBuffer[ ( *iIndex )++ ] = VAR;
|
|
strcpy( ucBuffer + ( *iIndex ), USER ); //no overflow. USER is const char *
|
|
*iIndex = *iIndex + strlen( USER ) ;
|
|
ucBuffer[ ( *iIndex )++ ] = VALUE;
|
|
strcpy(ucBuffer+( *iIndex ), szUser ); //no overflow. SzUser is valid, NULL terminated.
|
|
*iIndex = ( *iIndex ) + strlen( szUser);
|
|
}
|
|
|
|
{
|
|
//variable SYSTEMTYPE
|
|
ucBuffer[( *iIndex )++] = VAR;
|
|
strcpy(ucBuffer+( *iIndex ), SYSTEMTYPE ); //no overflow. SYSTEMTYPE is const char *
|
|
*iIndex = ( *iIndex ) + strlen( SYSTEMTYPE );
|
|
ucBuffer[( *iIndex )++] = VALUE;
|
|
strcpy(ucBuffer+( *iIndex ), WIN32_STRING );//no overflow. WIN32_STRING is const char *
|
|
*iIndex = ( *iIndex ) + strlen( WIN32_STRING );
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void
|
|
FProcessSB(WI * pwi, LPSTR *ps, int *recvsize)
|
|
{
|
|
unsigned char sbuf[16];
|
|
int inx;
|
|
int i = 0;
|
|
int cbLeft = *recvsize;
|
|
|
|
//
|
|
// Is the end of this option in the receive buffer?
|
|
//
|
|
|
|
while ( cbLeft )
|
|
{
|
|
if ( ((unsigned char) (*ps)[i]) == (unsigned char) SE )
|
|
goto Found;
|
|
|
|
cbLeft--;
|
|
i++;
|
|
}
|
|
|
|
//
|
|
// We ran out of buffer before finding the end of the option. IAC and
|
|
// SB were already eaten so add them
|
|
//
|
|
|
|
#ifdef TCPTEST
|
|
OutputDebugString("FProcessSB: saving incomplete option for next recv\n");
|
|
|
|
#endif
|
|
|
|
pwi->nd.lpTempBuffer[0] = (unsigned char) IAC;
|
|
pwi->nd.lpTempBuffer[1] = (unsigned char) SB;
|
|
|
|
for ( i = 2, cbLeft = (*recvsize+2); i < cbLeft; i++ )
|
|
pwi->nd.lpTempBuffer[i] = (*ps)[i-2];
|
|
|
|
pwi->nd.cbOld = *recvsize + 2;
|
|
*recvsize = 0;
|
|
|
|
return;
|
|
|
|
Found:
|
|
switch (*(unsigned char FAR *)(*ps)) {
|
|
|
|
case TO_NEW_ENVIRON:
|
|
|
|
//MBSC user name value now available in szUser
|
|
|
|
if( *(unsigned char FAR *)(*ps+1) == TT_SEND )
|
|
{
|
|
PUCHAR ucServerSentBuffer = *ps;
|
|
|
|
UCHAR ucBuffer[ MAX_BUFFER_SIZE + 2 ];
|
|
int iIndex = 0;
|
|
ucBuffer[ iIndex++ ] = ( UCHAR )IAC;
|
|
ucBuffer[ iIndex++] = ( UCHAR )SB;
|
|
ucBuffer[ iIndex++] = TO_NEW_ENVIRON;
|
|
ucBuffer[ iIndex++] = TT_IS;
|
|
inx = iIndex;
|
|
if( *(unsigned char FAR *)(ucServerSentBuffer+2) == IAC &&
|
|
*(unsigned char FAR *)(ucServerSentBuffer+3) == SE )
|
|
{
|
|
PutDefaultVarsInBuffer( ucBuffer, &inx );
|
|
}
|
|
|
|
else
|
|
{
|
|
ucServerSentBuffer = ucServerSentBuffer + 2 ; // eat TO_NEW_ENVIRON, TT_SEND
|
|
while ( !( *ucServerSentBuffer == IAC && *(ucServerSentBuffer+1) == SE )
|
|
&& inx < MAX_BUFFER_SIZE )
|
|
{
|
|
CHAR szVar[ MAX_STRING_LENGTH ];
|
|
CHAR *pcVal = NULL;
|
|
|
|
switch( *(unsigned char FAR *)(ucServerSentBuffer) )
|
|
{
|
|
case VAR:
|
|
( ucServerSentBuffer )++; //eat VAR
|
|
if( ( *ucServerSentBuffer == IAC &&
|
|
*(ucServerSentBuffer+1) == SE ) ||
|
|
*ucServerSentBuffer == USERVAR )
|
|
{
|
|
//send defaults
|
|
PutDefaultVarsInBuffer( ucBuffer, &inx );
|
|
}
|
|
else
|
|
{
|
|
ucServerSentBuffer += GetVariable( ucServerSentBuffer, szVar ); //GetVariable returns consumed net data
|
|
if( inx + strlen( szVar ) + 1 < MAX_BUFFER_SIZE )
|
|
{
|
|
ucBuffer[ inx++ ] = VAR;
|
|
|
|
//copy name of the variable
|
|
strncpy( ucBuffer+inx, szVar, MAX_BUFFER_SIZE - inx);
|
|
inx += strlen( szVar );
|
|
}
|
|
|
|
//now copy the value if defined
|
|
if( strcmp( szVar, USER ) == 0 )
|
|
{
|
|
if( inx + strlen( szUser ) + 1 < MAX_BUFFER_SIZE )
|
|
{
|
|
ucBuffer[inx++] = VALUE;
|
|
strncpy(ucBuffer+inx, szUser, MAX_BUFFER_SIZE - inx );
|
|
inx = inx + strlen( szUser);
|
|
}
|
|
}
|
|
else if( strncmp( szVar, SYSTEMTYPE, strlen( SYSTEMTYPE ) ) == 0 )
|
|
{
|
|
if( inx + strlen( WIN32_STRING ) + 1 < MAX_BUFFER_SIZE )
|
|
{
|
|
ucBuffer[inx++] = VALUE;
|
|
strncpy(ucBuffer+ inx, WIN32_STRING,MAX_BUFFER_SIZE - inx );
|
|
inx = inx + strlen( WIN32_STRING );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//do nothing. It means, variable is undefined
|
|
}
|
|
}
|
|
break;
|
|
|
|
case USERVAR:
|
|
( ucServerSentBuffer )++; //eat USERVAR
|
|
if( ( *ucServerSentBuffer == IAC &&
|
|
*(ucServerSentBuffer+1) == SE ) ||
|
|
*ucServerSentBuffer == VAR )
|
|
{
|
|
//send defaults ie; NONE
|
|
}
|
|
else
|
|
{
|
|
//Send the variable that is asked for
|
|
|
|
DWORD dwSize = 0;
|
|
|
|
ucServerSentBuffer += GetVariable( ucServerSentBuffer, szVar );
|
|
if( inx + strlen( szVar ) + 1 < MAX_BUFFER_SIZE )
|
|
{
|
|
ucBuffer[inx++] = USERVAR;
|
|
strncpy( ucBuffer+inx, szVar,MAX_BUFFER_SIZE - inx );
|
|
inx += strlen( szVar );
|
|
}
|
|
|
|
dwSize = GetEnvironmentVariableA( szVar, NULL, 0 );
|
|
|
|
if( dwSize > 0 )
|
|
{
|
|
pcVal = ( CHAR * ) malloc( dwSize + DELTA ); //This delta is meant for
|
|
//holding any ESC chars
|
|
if( !pcVal )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( GetEnvironmentVariableA( szVar, pcVal, dwSize ) )
|
|
{
|
|
INT x = 0;
|
|
INT iNeedForEsc = 0;
|
|
CHAR cVar = VAR, cUserVar = USERVAR;
|
|
|
|
x = strlen( pcVal ) - 1;
|
|
while( x >= 0 )
|
|
{
|
|
if( pcVal[ x ] >= cVar && pcVal[ x ] <= cUserVar )
|
|
{
|
|
//needs an ESC char
|
|
iNeedForEsc++;
|
|
}
|
|
|
|
x--;
|
|
}
|
|
|
|
if( iNeedForEsc && iNeedForEsc < DELTA )
|
|
{
|
|
x = strlen( pcVal );
|
|
|
|
//Null char is same as of VAR. So, special case.
|
|
pcVal[ x + iNeedForEsc ] = pcVal[ x-- ];
|
|
|
|
while( x >= 0 )
|
|
{
|
|
pcVal[ x + iNeedForEsc ] = pcVal[ x ];
|
|
if( pcVal[ x ] >= cVar && pcVal[ x ] <= cUserVar )
|
|
{
|
|
//needs an ESC char
|
|
iNeedForEsc--;
|
|
pcVal[ x + iNeedForEsc ] = ESC;
|
|
}
|
|
|
|
x--;
|
|
}
|
|
}
|
|
|
|
if( inx + strlen( pcVal ) + 1 < MAX_STRING_LENGTH )
|
|
{
|
|
//write VALUE keyword
|
|
ucBuffer[inx++] = VALUE;
|
|
|
|
//write actual value
|
|
strncpy(ucBuffer+ inx, pcVal,MAX_BUFFER_SIZE - inx );
|
|
inx = inx + strlen( pcVal );
|
|
}
|
|
}
|
|
free( pcVal );
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ASSERT( 0 ); //This should not happen. Only types we know are VAR and USERVAR
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ucBuffer[inx++] = ( UCHAR )IAC;
|
|
ucBuffer[inx++] = ( UCHAR )SE;
|
|
FWriteToNet(pwi, ucBuffer, inx);
|
|
}
|
|
|
|
break;
|
|
|
|
case TO_TERM_TYPE:
|
|
|
|
// This is guaranteed to happen after an authentication has happened so we can start obeying the
|
|
// local echo settings...
|
|
|
|
ui.fDebug |= ui.honor_localecho; // restore the saved echo settings.
|
|
|
|
if( *(unsigned char FAR *)(*ps+1) == TT_SEND )
|
|
{
|
|
|
|
sbuf[0] = IAC;
|
|
sbuf[1] = SB;
|
|
sbuf[2] = TO_TERM_TYPE;
|
|
sbuf[3] = TT_IS;
|
|
inx = 4;
|
|
|
|
if( pwi->trm.SentTermType == TT_UNKNOWN &&
|
|
pwi->trm.RequestedTermType != TT_UNKNOWN )
|
|
{
|
|
// we haven't started the negotiation yet and the user has specified
|
|
// a preferred term type, so we start with that.
|
|
// RequestedTermType here is the user's setting not the server's.
|
|
pwi->trm.CurrentTermType = pwi->trm.RequestedTermType;
|
|
pwi->trm.FirstTermTypeSent = pwi->trm.CurrentTermType;
|
|
}
|
|
else
|
|
{
|
|
pwi->trm.CurrentTermType = (pwi->trm.CurrentTermType + 1) % 4;
|
|
|
|
if( pwi->trm.CurrentTermType == pwi->trm.FirstTermTypeSent )
|
|
pwi->trm.CurrentTermType = pwi->trm.SentTermType;
|
|
}
|
|
//write maximum number of n bytes where n = sizeof(sbuf)-CurrentLength(sbuf)-2BytesForIACandSE-1ForNULL
|
|
strncpy( (char *) sbuf+4, rgchTermType[pwi->trm.CurrentTermType],16 - strlen(sbuf) -2 -1);
|
|
inx += strlen(rgchTermType[pwi->trm.CurrentTermType]);
|
|
|
|
sbuf[inx++] = IAC;
|
|
sbuf[inx++] = SE;
|
|
|
|
// set the Sent TermType to what we just sent
|
|
pwi->trm.SentTermType = pwi->trm.CurrentTermType ;
|
|
|
|
|
|
FWriteToNet(pwi, ( char * )sbuf, inx);
|
|
}
|
|
|
|
break;
|
|
|
|
#if 1
|
|
case TO_AUTH:
|
|
|
|
if( (*(unsigned char FAR *)(*ps+1) == AU_SEND) && (*(unsigned char FAR *)(*ps+2) == AUTH_TYPE_NTLM) )
|
|
{
|
|
if ( pwi->eState!= Connecting || !PromptUser() || !StartNTLMAuth(pwi) )
|
|
{
|
|
// there has been an error.
|
|
|
|
pwi->eState = Telnet;
|
|
|
|
sbuf[0] = IAC;
|
|
sbuf[1] = SB;
|
|
sbuf[2] = TO_AUTH;
|
|
sbuf[3] = AU_IS;
|
|
sbuf[4] = AUTH_TYPE_NULL;
|
|
sbuf[5] = 0;
|
|
sbuf[6] = IAC;
|
|
sbuf[7] = SE;
|
|
|
|
FWriteToNet(pwi, ( char * )sbuf, 8);
|
|
|
|
}
|
|
}
|
|
else if( (*(unsigned char FAR *)(*ps+1) == AU_REPLY) && (*(unsigned char FAR *)(*ps+2) == AUTH_TYPE_NTLM) )
|
|
{
|
|
// ps + 3 is the modifier and for NTLM it is AUTH_CLIENT_TO_SERVER & AUTH_ONE_WAY.
|
|
// ps + 4 is the NTLM accept or NTLM challenge or NTLM reject
|
|
|
|
switch ( *(unsigned char FAR *)(*ps+4) )
|
|
{
|
|
|
|
case NTLM_CHALLENGE:
|
|
if( pwi->eState != Authenticating || !DoNTLMAuth(pwi, (unsigned char FAR *)(*ps+5), *recvsize-5) )
|
|
{
|
|
// there has been an error.
|
|
|
|
pwi->eState = Telnet;
|
|
|
|
sbuf[0] = IAC;
|
|
sbuf[1] = SB;
|
|
sbuf[2] = TO_AUTH;
|
|
sbuf[3] = AU_IS;
|
|
sbuf[4] = AUTH_TYPE_NULL;
|
|
sbuf[5] = 0;
|
|
sbuf[6] = IAC;
|
|
sbuf[7] = SE;
|
|
|
|
FWriteToNet(pwi, ( char * )sbuf, 8);
|
|
}
|
|
break;
|
|
case NTLM_ACCEPT:
|
|
//fall through
|
|
case NTLM_REJECT:
|
|
//fall through
|
|
default:
|
|
pwi->eState = Telnet;
|
|
if( pwi->eState == Authenticating || pwi->eState == AuthChallengeRecvd )
|
|
{
|
|
NTLMCleanup();
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
pwi->eState = Telnet;
|
|
|
|
sbuf[0] = IAC;
|
|
sbuf[1] = SB;
|
|
sbuf[2] = TO_AUTH;
|
|
sbuf[3] = AU_IS;
|
|
sbuf[4] = AUTH_TYPE_NULL;
|
|
sbuf[5] = 0;
|
|
sbuf[6] = IAC;
|
|
sbuf[7] = SE;
|
|
|
|
FWriteToNet(pwi, ( char * )sbuf, 8);
|
|
}
|
|
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
while (*(unsigned char FAR *)(*ps) != SE) {
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
*recvsize = *recvsize - 1;
|
|
}
|
|
|
|
//
|
|
// Do one more to step over the SE
|
|
//
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
*recvsize = *recvsize - 1;
|
|
|
|
}
|
|
|
|
void
|
|
FProcessIAC(
|
|
HWND hwnd,
|
|
WI * pwi,
|
|
LPSTR * ps,
|
|
LPSTR * pd,
|
|
int * recvsize,
|
|
int * t_size)
|
|
{
|
|
UCHAR ch = *(unsigned char FAR *)(*ps);
|
|
|
|
ui.nottelnet = FALSE; // We can safely say that we are talking to a telnet server now...
|
|
|
|
//
|
|
// The IAC has already been subtracted from *recvsize
|
|
//
|
|
|
|
//
|
|
// Make sure we have enough recv buffer to process the rest of the IAC
|
|
// We know the DO, DONT etc. options always take two bytes plus the IAC.
|
|
//
|
|
|
|
if ( ((ch == DONT || ch == DO ||
|
|
ch == WILL || ch == WONT) && *recvsize < 2) ||
|
|
(ch != SB && *recvsize < 1) )
|
|
{
|
|
int i;
|
|
|
|
#ifdef TCPTEST
|
|
OutputDebugString("FProcessIAC: saving incomplete option for next recv\n");
|
|
#endif
|
|
|
|
//
|
|
// IAC was previously eaten
|
|
//
|
|
|
|
pwi->nd.lpTempBuffer[0] = (unsigned char) IAC;
|
|
|
|
for ( i = 1; i < (*recvsize+1); i++ )
|
|
pwi->nd.lpTempBuffer[i] = (*ps)[i-1];
|
|
|
|
pwi->nd.cbOld = *recvsize + 1;
|
|
*recvsize = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
switch (*(unsigned char FAR *)(*ps)) {
|
|
|
|
case DONT:
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
/* process options */
|
|
FProcessDont(pwi, ps);
|
|
|
|
#ifdef TCPTEST
|
|
OutputDebugString("DONT \n");
|
|
#endif
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
*recvsize = *recvsize - 2;
|
|
break;
|
|
|
|
case DO:
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
/* process options */
|
|
FProcessDo(pwi, ps);
|
|
#ifdef TCPTEST
|
|
OutputDebugString("DO \n");
|
|
#endif
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
*recvsize = *recvsize - 2;
|
|
break;
|
|
|
|
case WONT:
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
/* process options */
|
|
FProcessWont(pwi, ps);
|
|
#ifdef TCPTEST
|
|
OutputDebugString("WONT \n");
|
|
#endif
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
*recvsize = *recvsize - 2;
|
|
break;
|
|
|
|
case WILL:
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
/* process options */
|
|
FProcessWill(pwi, ps);
|
|
|
|
#ifdef TCPTEST
|
|
OutputDebugString("WILL \n");
|
|
#endif
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
*recvsize = *recvsize - 2;
|
|
break;
|
|
|
|
case SB:
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
*recvsize -= 1;
|
|
|
|
/* process options */
|
|
FProcessSB(pwi, ps, recvsize);
|
|
break;
|
|
|
|
default:
|
|
|
|
(*ps) = (char FAR *)(*ps) + 1;
|
|
|
|
*recvsize -= 1;
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef TCPTEST
|
|
VOID DumpBuffer( VOID FAR * pbuff, DWORD cb )
|
|
{
|
|
#define NUM_CHARS 16
|
|
DWORD i, limit;
|
|
CHAR TextBuffer[NUM_CHARS + 1];
|
|
LPBYTE BufferPtr;
|
|
|
|
if ( !pbuff )
|
|
{
|
|
OutputDebugString("No buffer\n");
|
|
return;
|
|
}
|
|
|
|
|
|
BufferPtr = (LPBYTE) pbuff;
|
|
|
|
//
|
|
// Hex dump of the bytes
|
|
//
|
|
limit = ((cb - 1) / NUM_CHARS + 1) * NUM_CHARS;
|
|
|
|
for (i = 0; i < limit; i++) {
|
|
|
|
if (i < cb) {
|
|
|
|
snprintf(DebugBuffer,sizeof(DebugBuffer)-1, "%02x ", BufferPtr[i]);
|
|
OutputDebugString( DebugBuffer );
|
|
|
|
if (BufferPtr[i] < 31 ) {
|
|
TextBuffer[i % NUM_CHARS] = '.';
|
|
} else if (BufferPtr[i] == '\0') {
|
|
TextBuffer[i % NUM_CHARS] = ' ';
|
|
} else {
|
|
TextBuffer[i % NUM_CHARS] = (CHAR) BufferPtr[i];
|
|
}
|
|
|
|
} else {
|
|
|
|
OutputDebugString(" ");
|
|
TextBuffer[i % NUM_CHARS] = ' ';
|
|
}
|
|
|
|
if ((i + 1) % NUM_CHARS == 0) {
|
|
TextBuffer[NUM_CHARS] = 0;
|
|
snprintf(DebugBuffer,sizeof(DebugBuffer)-1, " %s\n", TextBuffer);
|
|
OutputDebugString( DebugBuffer );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void FProcessSessionData( int cBytes, PUCHAR pchNBBuffer, WI *pwi )
|
|
{
|
|
WaitForSingleObject( g_hCaptureConsoleEvent, INFINITE );
|
|
|
|
WaitForSingleObject( g_hRemoteNEscapeModeDataSync, INFINITE );
|
|
if( pwi->hOutput != g_hSessionConsoleBuffer )
|
|
{
|
|
pwi->hOutput = g_hSessionConsoleBuffer;
|
|
SetConsoleActiveScreenBuffer(g_hSessionConsoleBuffer);
|
|
}
|
|
/*This is needed so that we don't write data to the session even after disconnection of client */
|
|
if( !fConnected )
|
|
{
|
|
return;
|
|
}
|
|
|
|
ResetEvent( g_hRemoteNEscapeModeDataSync );
|
|
if( pwi->trm.CurrentTermType == TT_VTNT )
|
|
{
|
|
if( !DoVTNTOutput(pwi, &pwi->trm, cBytes, pchNBBuffer) )
|
|
{
|
|
//
|
|
// The following two lines were originally added as a
|
|
// mechanism of defaulting to VT100 in case of some servers
|
|
// accepting VTNT, during term type negotiation, even though
|
|
// in reality they do not support VTNT. Specifically, Linux
|
|
// was showing this behavior during our testing. But the
|
|
// function DoVTNTOutput returns FALSE even in other cases
|
|
// such as, when we get some junk data from the server. In
|
|
// such cases we should not call DoIBMANSIOutput (bug 1119).
|
|
//
|
|
pwi->trm.CurrentTermType = TT_ANSI;
|
|
DoIBMANSIOutput(pwi, &pwi->trm, cBytes, pchNBBuffer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DoIBMANSIOutput(pwi, &pwi->trm, cBytes, pchNBBuffer);
|
|
}
|
|
|
|
pwi->ichTelXfer = 0;
|
|
SetEvent( g_hRemoteNEscapeModeDataSync );
|
|
}
|
|
|
|
|
|
void
|
|
FProcessFDRead(HWND hwnd)
|
|
{
|
|
WI *pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
int recvsize, t_size;
|
|
LPSTR ps, pd;
|
|
|
|
//
|
|
// pwi->nd.cbOld Is the number of bytes left over from the previous
|
|
// packet that we kept in pwi->nd.lpTempBuffer
|
|
//
|
|
|
|
if ((recvsize=recv(pwi->nd.hsd,
|
|
pwi->nd.lpTempBuffer + pwi->nd.cbOld,
|
|
READ_BUF_SZ - pwi->nd.cbOld,
|
|
0)) < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Fix to bug 284
|
|
//
|
|
Sleep(0);
|
|
|
|
recvsize += pwi->nd.cbOld;
|
|
pwi->nd.cbOld = 0;
|
|
|
|
ps = pwi->nd.lpTempBuffer;
|
|
pd = pwi->nd.lpReadBuffer;
|
|
t_size = 0;
|
|
|
|
while( recvsize-- )
|
|
{
|
|
|
|
if( *(unsigned char FAR *) ps == (unsigned char)IAC )
|
|
{
|
|
|
|
if( recvsize == 0 )
|
|
{
|
|
pwi->nd.lpTempBuffer[0] = (unsigned char) IAC;
|
|
pwi->nd.cbOld = 1;
|
|
break;
|
|
}
|
|
|
|
ps++;
|
|
|
|
if( *(unsigned char FAR *)ps == (unsigned char)IAC )
|
|
{
|
|
|
|
//
|
|
// This was an escaped IAC so put it in the normal
|
|
// input buffer
|
|
//
|
|
|
|
ps++;
|
|
*(unsigned char FAR *)pd = (unsigned char)IAC;
|
|
pd++;
|
|
|
|
recvsize--;
|
|
|
|
t_size++;
|
|
}
|
|
else
|
|
{
|
|
FProcessIAC(hwnd, pwi, &ps, &pd, &recvsize, &t_size);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
*(char FAR *)pd = *(char FAR *)ps;
|
|
pd++;
|
|
ps++;
|
|
|
|
t_size++;
|
|
}
|
|
}
|
|
|
|
if( t_size )
|
|
{
|
|
/* add received data to buffer */
|
|
if ( !(ui.fFlushOut) || ui.nottelnet )
|
|
{
|
|
FProcessSessionData( t_size, pwi->nd.lpReadBuffer, pwi );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
FProcessFDOOB(HWND hwnd)
|
|
{
|
|
WI *pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
int recvsize;
|
|
LPSTR ps;
|
|
|
|
if ((recvsize=recv(pwi->nd.hsd, pwi->nd.lpTempBuffer,
|
|
READ_BUF_SZ, MSG_OOB)) < 0) {
|
|
#ifdef TCPTEST
|
|
OutputDebugString("recv error \n");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
ps = pwi->nd.lpTempBuffer;
|
|
|
|
if (*(unsigned char *)ps == (unsigned char)DM)
|
|
{
|
|
#ifdef TCPTEST
|
|
OutputDebugString("DM received\n");
|
|
#endif
|
|
FDisableFlush(hwnd);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
FAttemptServerConnect(WI *pwi, LPSTR szHostName, LPNETDATA lpData)
|
|
{
|
|
BOOL got_connected = FALSE;
|
|
struct servent *serv;
|
|
struct sockaddr_storage myad;
|
|
int on = 1;
|
|
char szService[256];
|
|
char *pszService = NULL;
|
|
struct addrinfo *aiTemp = NULL;
|
|
|
|
g_dwSockErr = 0; //Intialize to no error
|
|
|
|
|
|
if(rgService)
|
|
{
|
|
pszService = szService;
|
|
_snprintf(pszService,sizeof(szService)-1, "%d",rgService);
|
|
}
|
|
else
|
|
{
|
|
got_connected = FALSE;
|
|
return(got_connected);
|
|
}
|
|
|
|
strncpy(lpData->szHostName, szHostName,sizeof(lpData->szHostName));
|
|
if(getaddrinfo(szHostName, pszService, NULL, &lpData->ai ) != 0 )
|
|
{
|
|
got_connected = FALSE;
|
|
return(got_connected);
|
|
}
|
|
aiTemp = lpData->ai;
|
|
ui.nottelnet = TRUE; // Assume that it is not a telnet server for starters, later when it is set this flag... to false.
|
|
ui.honor_localecho = (ui.fDebug & fdwLocalEcho); // Save this and restore after a logon has happned in case of telnet
|
|
ui.fDebug &= ~fdwLocalEcho; // Clear it.
|
|
//Continue till connection is successfully established or till the list is exausted
|
|
while(aiTemp)
|
|
{
|
|
if ((lpData->hsd = socket( aiTemp->ai_family, SOCK_STREAM, 0)) == INVALID_SOCKET)
|
|
{
|
|
DEBUG_PRINT(("socket failed \n"));
|
|
aiTemp = aiTemp->ai_next;
|
|
continue;
|
|
}
|
|
SfuZeroMemory(&myad, sizeof(myad)); //no overflow. Size is constant.
|
|
myad.ss_family = (u_short)aiTemp->ai_family;
|
|
if(bind( lpData->hsd, (struct sockaddr *)&myad, sizeof(myad))<0)
|
|
{
|
|
DEBUG_PRINT(("bind failed\n"));
|
|
closesocket( lpData->hsd );
|
|
lpData->hsd = INVALID_SOCKET;
|
|
aiTemp = aiTemp->ai_next;
|
|
continue;
|
|
}
|
|
on = 1;
|
|
{
|
|
BOOL value_to_set = TRUE;
|
|
|
|
setsockopt(
|
|
lpData->hsd,
|
|
SOL_SOCKET,
|
|
SO_DONTLINGER,
|
|
( char * )&value_to_set,
|
|
sizeof( value_to_set )
|
|
);
|
|
}
|
|
if( setsockopt( lpData->hsd, SOL_SOCKET, SO_OOBINLINE,
|
|
(char *)&on, sizeof(on) ) < 0)
|
|
{
|
|
g_dwSockErr = WSAGetLastError();
|
|
closesocket( lpData->hsd );
|
|
lpData->hsd = INVALID_SOCKET;
|
|
got_connected = FALSE;
|
|
DEBUG_PRINT(("setsockopt SO_OOBINLINE failed\n"));
|
|
DEBUG_PRINT(("FAttemptServerConnect Out\n"));
|
|
freeaddrinfo(lpData->ai);
|
|
lpData->ai = NULL;
|
|
return(got_connected);
|
|
}
|
|
else
|
|
DEBUG_PRINT(("setsockopt SO_OOBINLINE worked\n"));
|
|
|
|
if(SafeSetSocketOptions(lpData->hsd) < 0)
|
|
{
|
|
g_dwSockErr = WSAGetLastError();
|
|
closesocket( lpData->hsd );
|
|
lpData->hsd = INVALID_SOCKET;
|
|
got_connected = FALSE;
|
|
DEBUG_PRINT(("setsockopt SO_EXCLUSIVEADDRUSE failed\n"));
|
|
DEBUG_PRINT(("FAttemptServerConnect Out\n"));
|
|
freeaddrinfo(lpData->ai);
|
|
lpData->ai = NULL;
|
|
return(got_connected);
|
|
}
|
|
|
|
// ================================================================
|
|
// MohsinA, 09-Dec-96.
|
|
|
|
if(connect( lpData->hsd, (PVOID)aiTemp->ai_addr,aiTemp->ai_addrlen )<0)
|
|
{
|
|
DEBUG_PRINT(("connect failed\n"));
|
|
closesocket( lpData->hsd );
|
|
lpData->hsd = INVALID_SOCKET;
|
|
aiTemp = aiTemp->ai_next;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
freeaddrinfo(lpData->ai);
|
|
lpData->ai = NULL;
|
|
if(aiTemp == NULL)
|
|
{
|
|
DEBUG_PRINT(("FAttemptServerConnect Out\n"));
|
|
g_dwSockErr = WSAGetLastError();
|
|
if(lpData->hsd != INVALID_SOCKET)
|
|
closesocket( lpData->hsd );
|
|
lpData->hsd = INVALID_SOCKET;
|
|
got_connected = FALSE;
|
|
return(got_connected);
|
|
}
|
|
aiTemp=NULL;
|
|
// ================================================================
|
|
|
|
lpData->SessionNumber = 1;
|
|
|
|
if (lpData->SessionNumber != nSessionNone)
|
|
{
|
|
DEBUG_PRINT(("sess# <> nsessnone\n"));
|
|
/* post Async select */
|
|
if (WSAAsyncSelect( lpData->hsd, pwi->hwnd, WS_ASYNC_SELECT,
|
|
(FD_READ | FD_WRITE | FD_CLOSE | FD_OOB)) < 0)
|
|
{
|
|
g_dwSockErr = WSAGetLastError();
|
|
closesocket( lpData->hsd );
|
|
lpData->hsd = INVALID_SOCKET;
|
|
got_connected = FALSE;
|
|
lpData->SessionNumber = nSessionNone;
|
|
DEBUG_PRINT(("WSAAsyncSelect failed\n"));
|
|
DEBUG_PRINT(("FAttemptServerConnect Out\n"));
|
|
return(got_connected);
|
|
}
|
|
else
|
|
DEBUG_PRINT(("WSAAsyncSelect worked\n"));
|
|
got_connected = TRUE;
|
|
}
|
|
else
|
|
DEBUG_PRINT(("sess# <> nsessnone\n"));
|
|
DEBUG_PRINT(("FAttemptServerConnect Out\n"));
|
|
return got_connected;
|
|
}
|
|
|
|
void
|
|
FCloseConnection(HWND hwnd)
|
|
{
|
|
WI *pwi = (WI *)GetWindowLongPtr(hwnd, WL_TelWI);
|
|
if(pwi->nd.hsd != INVALID_SOCKET)
|
|
{
|
|
closesocket( pwi->nd.hsd );
|
|
pwi->nd.hsd = INVALID_SOCKET;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef __NOT_USED
|
|
#define INC(i) (((i)+1 == DATA_BUF_SZ) ? 0 : (i)+1)
|
|
#define DEC(i) (((i)-1 < 0) ? DATA_BUF_SZ-1 : (i)-1)
|
|
|
|
WORD
|
|
WGetData(LPNETDATA lpData, LPSTR lpBuffer, WORD cLen)
|
|
{
|
|
WORD cb;
|
|
|
|
#ifdef TCPTEST
|
|
snprintf(DebugBuffer,sizeof(DebugBuffer)-1, "WGetData length %d\n", cLen);
|
|
OutputDebugString(DebugBuffer);
|
|
#endif
|
|
if (lpData->iHead < lpData->iTail)
|
|
{
|
|
cb = ( USHORT ) ( (cLen < (lpData->iTail - lpData->iHead - 1))
|
|
? cLen : (lpData->iTail - lpData->iHead - 1) );
|
|
memcpy(lpBuffer, &lpData->achData[lpData->iHead+1], cb); //Attack ? size not known. No caller.
|
|
lpData->iHead = ( USHORT ) ( lpData->iHead + cb );
|
|
}
|
|
else
|
|
{
|
|
for(cb=0;
|
|
(cb<cLen) && ((WORD)INC(lpData->iHead) != lpData->iTail);
|
|
++cb)
|
|
{
|
|
lpData->iHead = ( USHORT ) INC(lpData->iHead);
|
|
*lpBuffer++ = lpData->achData[lpData->iHead];
|
|
}
|
|
}
|
|
|
|
#ifdef TCPTEST
|
|
snprintf(DebugBuffer, sizeof(DebugBuffer)-1, "WGetData returning %d bytes (head = %d, tail = %d)\n",
|
|
cb,
|
|
lpData->iHead,
|
|
lpData->iTail );
|
|
OutputDebugString(DebugBuffer);
|
|
#endif
|
|
|
|
return cb;
|
|
}
|
|
|
|
BOOL
|
|
FStoreData(LPNETDATA lpData, int max)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
WORD tail = lpData->iTail;
|
|
LPSTR p = lpData->lpReadBuffer;
|
|
|
|
#ifdef TCPTEST
|
|
snprintf(DebugBuffer, sizeof(DebugBuffer)-1, "FStoreData max %d, (head = %d, tail = %d)\n",
|
|
max,
|
|
tail,
|
|
lpData->iHead );
|
|
OutputDebugString(DebugBuffer);
|
|
#endif
|
|
|
|
if ((max+tail) < DATA_BUF_SZ)
|
|
{
|
|
memcpy(&lpData->achData[tail], p, max); //Attack ? Size not known. No caller.
|
|
tail = ( USHORT ) ( tail + max );
|
|
}
|
|
else
|
|
{
|
|
WORD head = lpData->iHead;
|
|
int i;
|
|
|
|
for (i=0; i<max; ++i)
|
|
{
|
|
if (tail == head)
|
|
{
|
|
/* the buffer is full! Rest of the data will be lost */
|
|
fSuccess = FALSE;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
lpData->achData[tail] = *p++;
|
|
tail = ( USHORT ) INC(tail);
|
|
}
|
|
}
|
|
}
|
|
|
|
lpData->iTail = tail;
|
|
|
|
#ifdef TCPTEST
|
|
snprintf(DebugBuffer, sizeof(DebugBuffer)-1, "FStoreData returning %d\n",
|
|
fSuccess );
|
|
OutputDebugString(DebugBuffer);
|
|
#endif
|
|
|
|
return fSuccess;
|
|
}
|
|
#endif
|
|
|
|
void CALLBACK
|
|
NBReceiveData(PVOID pncb)
|
|
{
|
|
}
|
|
|
|
/* following four routines modified from VTP's routines. */
|
|
|
|
BOOL
|
|
FTelXferStart(WI *pwi, int nSessionNumber)
|
|
{
|
|
#ifdef TELXFER
|
|
unsigned short u;
|
|
char rgchFileOrig[OFS_MAXPATHNAME];
|
|
char rgchFile[OFS_MAXPATHNAME];
|
|
|
|
xfGetData(0, (char *)&u, 2, nSessionNumber); // Mode
|
|
|
|
SfuZeroMemory(&pwi->svi, sizeof(SVI)); //no overflow. Size is constant
|
|
pwi->svi.hfile = INVALID_HANDLE_VALUE;
|
|
pwi->svi.lExit = -1;
|
|
pwi->svi.lCleanup = -1;
|
|
|
|
if (u != 0) // For now must be zero
|
|
return FALSE;
|
|
|
|
pwi->trm.fHideCursor = TRUE;
|
|
|
|
xfGetData(1, (char *)&u, 2, nSessionNumber); // Length of name
|
|
xfGetData(2, rgchFileOrig, u, nSessionNumber); // Name
|
|
|
|
xfGetData(3, (char *)&pwi->svi.cbFile, 4, nSessionNumber); // Filesize
|
|
|
|
lstrcpyn(rgchFile, rgchFileOrig, OFS_MAXPATHNAME -1);
|
|
|
|
/* If the user doesn't have the shift key down, prompt for */
|
|
/* a directory and name for the file */
|
|
if (!(ui.fPrompt & fdwSuppressDestDirPrompt) &&
|
|
(GetAsyncKeyState(VK_SHIFT) >= 0))
|
|
{
|
|
if ( !FGetFileName(hwnd, rgchFile, NULL) )
|
|
{
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
pwi->svi.hfile = CreateFile(rgchFile, GENERIC_WRITE | GENERIC_READ,
|
|
FILE_SHARE_READ, NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
|
|
NULL);
|
|
if (pwi->svi.hfile == INVALID_HANDLE_VALUE)
|
|
{
|
|
ErrorMessage(szCantOpenFile, szAppName);
|
|
goto err;
|
|
}
|
|
pwi->svi.puchBuffer = LocalAlloc(LPTR, SV_DATABUF);
|
|
if (pwi->svi.puchBuffer == NULL)
|
|
{
|
|
ErrorMessage(szOOM, szAppName);
|
|
goto err;
|
|
}
|
|
|
|
pwi->svi.nSessionNumber = nSessionNumber;
|
|
pwi->svi.hthread = CreateThread(NULL, 0, SVReceive, &pwi->svi,
|
|
CREATE_SUSPENDED, &pwi->svi.dwThreadId);
|
|
if (pwi->svi.hthread == NULL)
|
|
{
|
|
ErrorMessage(szNoThread, szAppName);
|
|
goto err;
|
|
}
|
|
|
|
// Skip 4 which is ^D
|
|
xfPutc(5, nSessionNumber); // Get file
|
|
|
|
_snwprintf(rgchFile, OFS_MAXPATHNAME -1, szBannerMessage, rgchFileOrig, pwi->svi.cbFile);
|
|
DoIBMANSIOutput(hwnd, &pwi->trm, lstrlen(rgchFile), rgchFile);
|
|
|
|
DoIBMANSIOutput(hwnd, &pwi->trm, lstrlen(szInitialProgress), szInitialProgress);
|
|
|
|
/* In case the screen just scrolled up, paint the window */
|
|
UpdateWindow( hwnd );
|
|
ResumeThread( pwi->svi.hthread );
|
|
|
|
return TRUE;
|
|
|
|
err:
|
|
if ( pwi )
|
|
{
|
|
if (pwi->svi.puchBuffer != NULL)
|
|
LocalFree( (HANDLE)pwi->svi.puchBuffer );
|
|
if (pwi->svi.hfile != INVALID_HANDLE_VALUE)
|
|
CloseHandle( pwi->svi.hfile );
|
|
|
|
SfuZeroMemory(&pwi->svi, sizeof(SVI)); //no overflow. size is constant.
|
|
pwi->svi.hfile = INVALID_HANDLE_VALUE;
|
|
pwi->svi.lExit = -1;
|
|
pwi->svi.lCleanup = -1;
|
|
}
|
|
pwi->trm.fHideCursor = FALSE;
|
|
|
|
return FALSE;
|
|
#else
|
|
return TRUE;
|
|
#endif
|
|
}
|
|
|
|
|
|
BOOL
|
|
FTelXferEnd(WI *pwi, DWORD dwWhy)
|
|
{
|
|
#ifdef TELXFER
|
|
DWORD dwStatus = NO_ERROR;
|
|
BOOL fTransferOK = FALSE;
|
|
BOOL fAbortDownload = FALSE;
|
|
BOOL fCleanup = FALSE;
|
|
LPNETDATA lpData = &pwi->nd;
|
|
SVI *psvi = &pwi->svi;
|
|
MSG msg;
|
|
|
|
switch ( dwWhy )
|
|
{
|
|
case SV_DISCONNECT:
|
|
case SV_HANGUP:
|
|
case SV_QUIT:
|
|
if (InterlockedIncrement(&psvi->lExit) == 0)
|
|
{
|
|
if (psvi->hthread != NULL)
|
|
{
|
|
(void)GetExitCodeThread(psvi->hthread, &dwStatus);
|
|
if (dwStatus == STILL_ACTIVE)
|
|
{
|
|
if (MessageBox(hwnd, szAbortDownload, szAppName,
|
|
MB_DEFBUTTON2 | MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
|
|
{
|
|
fAbortDownload = fCleanup = TRUE;
|
|
}
|
|
|
|
/* See if the thread has finished yet */
|
|
GetExitCodeThread(psvi->hthread, &dwStatus);
|
|
|
|
if ( fAbortDownload )
|
|
{
|
|
/* If the thread hasn't finished yet, tell it to stop */
|
|
if (dwStatus == STILL_ACTIVE)
|
|
{
|
|
HCURSOR hcursorOld;
|
|
hcursorOld = SetCursor( LoadCursor(NULL, IDC_WAIT));
|
|
psvi->dwCommand = 1;
|
|
WaitForSingleObject(psvi->hthread, INFINITE);
|
|
GetExitCodeThread(psvi->hthread, &dwStatus);
|
|
(void)SetCursor( hcursorOld );
|
|
}
|
|
|
|
/* "Eat" any progress messages that might be around */
|
|
while (PeekMessage(&msg, hwnd, SV_PROGRESS, SV_DONE,
|
|
PM_REMOVE))
|
|
{
|
|
if (msg.message == SV_PROGRESS)
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
}
|
|
}
|
|
else if (dwStatus != STILL_ACTIVE)
|
|
{
|
|
fCleanup = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fAbortDownload = fCleanup = TRUE;
|
|
}
|
|
|
|
/* If we've stopped the download, then close the thread */
|
|
if ( fCleanup )
|
|
{
|
|
CloseHandle( psvi->hthread );
|
|
psvi->hthread = NULL;
|
|
if (lpData->SessionNumber != nSessionNone)
|
|
{
|
|
xfPutc((char)(!fTransferOK ? 0x7F : 0x06),
|
|
lpData->SessionNumber);
|
|
if ( !fAbortDownload )
|
|
(void)FPostReceive( lpData );
|
|
}
|
|
}
|
|
if (dwStatus == NO_ERROR)
|
|
fTransferOK = TRUE;
|
|
}
|
|
InterlockedDecrement( &psvi->lExit );
|
|
|
|
/* If the thread wasn't aborted and it hasn't finished, return */
|
|
if (!fAbortDownload && !fCleanup)
|
|
return fAbortDownload;
|
|
}
|
|
else
|
|
{
|
|
InterlockedDecrement( &psvi->lExit );
|
|
break;
|
|
}
|
|
|
|
case SV_DONE:
|
|
if (dwWhy == SV_DONE)
|
|
{
|
|
fAbortDownload = fCleanup = TRUE;
|
|
}
|
|
|
|
/* If we're the only thread in the function, close everything down */
|
|
if (InterlockedIncrement(&psvi->lExit) == 0)
|
|
{
|
|
if (psvi->hthread != NULL)
|
|
{
|
|
WaitForSingleObject(psvi->hthread, INFINITE);
|
|
GetExitCodeThread(psvi->hthread, &dwStatus);
|
|
CloseHandle( psvi->hthread );
|
|
psvi->hthread = NULL;
|
|
if (dwStatus == NO_ERROR)
|
|
fTransferOK = TRUE;
|
|
}
|
|
}
|
|
|
|
/* Do cleanup of struct only once */
|
|
if ((InterlockedIncrement(&psvi->lCleanup) == 0) &&
|
|
(psvi->puchBuffer != NULL))
|
|
{
|
|
LocalFree( (HANDLE)psvi->puchBuffer );
|
|
psvi->puchBuffer = NULL;
|
|
|
|
if (psvi->hfile != INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle( psvi->hfile );
|
|
psvi->hfile = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
psvi->cbFile = 0;
|
|
psvi->cbReadTotal = 0;
|
|
psvi->dwCommand = 0;
|
|
psvi->dwThreadId = 0;
|
|
psvi->nSessionNumber = nSessionNone;
|
|
|
|
if ((dwStatus == NO_ERROR) || (dwStatus == ERROR_OPERATION_ABORTED))
|
|
{
|
|
lstrcpyn(pchNBBuffer, szSendTelEnd,sizeof(pchNBBuffer)-1);
|
|
}
|
|
else
|
|
{
|
|
_snwprintf(pchNBBuffer,sizeof(pchNBBuffer)-1,szSendTelError, dwStatus);
|
|
}
|
|
DoIBMANSIOutput(hwnd, &pwi->trm, lstrlen(pchNBBuffer), pchNBBuffer);
|
|
|
|
pwi->ichTelXfer = 0;
|
|
pwi->trm.fHideCursor = FALSE;
|
|
}
|
|
InterlockedDecrement( &psvi->lCleanup );
|
|
|
|
if ((dwWhy == SV_DONE) && (lpData->SessionNumber != nSessionNone))
|
|
{
|
|
xfPutc((char)(!fTransferOK ? 0x7F : 0x06), lpData->SessionNumber);
|
|
(void)FPostReceive( lpData );
|
|
}
|
|
InterlockedDecrement( &psvi->lExit );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return fAbortDownload;
|
|
#else
|
|
return TRUE;
|
|
#endif
|
|
}
|
|
|
|
#ifdef TELXFER
|
|
static void
|
|
xfGetData(char c, char *pchBuffer, DWORD cbBuffer, int nSessionNumber)
|
|
{
|
|
DWORD cbRead;
|
|
|
|
xfPutc(c, nSessionNumber);
|
|
while ( cbBuffer )
|
|
{
|
|
cbRead = xfGetSomeData(pchBuffer, cbBuffer, nSessionNumber);
|
|
if (cbRead == 0)
|
|
break;
|
|
cbBuffer -= cbRead;
|
|
pchBuffer += cbRead;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef USETCP
|
|
#ifdef TELXFER
|
|
static DWORD
|
|
xfGetSomeData(char *pchBuffer, DWORD cbBuffer, int nSessionNumber)
|
|
{
|
|
return 1;
|
|
}
|
|
#endif //TELXFER
|
|
|
|
|
|
#ifdef TELXFER
|
|
static void
|
|
xfPutc(char c, int nSessionNumber)
|
|
{
|
|
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef TELXFER
|
|
BOOL
|
|
FGetFileName(HWND hwndOwner, char *rgchFile, char *rgchTitle)
|
|
{
|
|
OPENFILENAME ofn;
|
|
|
|
/* Fill in struct. */
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hwndOwner = hwndOwner;
|
|
ofn.hInstance = NULL;
|
|
ofn.lpstrFilter = (LPSTR) szAllFiles;
|
|
ofn.lpstrCustomFilter = (LPSTR) NULL;
|
|
ofn.nMaxCustFilter = 0;
|
|
ofn.nFilterIndex = 0;
|
|
ofn.lpstrFile = (LPSTR) rgchFile;
|
|
ofn.nMaxFile = OFS_MAXPATHNAME;
|
|
ofn.lpstrFileTitle = (LPSTR) rgchTitle;
|
|
ofn.nMaxFileTitle = OFS_MAXPATHNAME;
|
|
ofn.lpstrInitialDir = (LPSTR) 0;
|
|
ofn.lpstrTitle = (LPSTR) szDownloadAs;
|
|
ofn.Flags = OFN_HIDEREADONLY | OFN_NOREADONLYRETURN |
|
|
OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
|
|
|
|
ofn.nFileOffset = 0;
|
|
ofn.nFileExtension = 0;
|
|
ofn.lpstrDefExt = (LPSTR) NULL;
|
|
ofn.lCustData = 0;
|
|
ofn.lpfnHook = NULL;
|
|
ofn.lpTemplateName = NULL;
|
|
|
|
if ( !GetSaveFileName(&ofn) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
DWORD WINAPI
|
|
SVReceive(SVI *psvi)
|
|
{
|
|
DWORD dwReturn = NO_ERROR;
|
|
|
|
#ifdef TELXFER
|
|
if ( psvi )
|
|
{
|
|
while ((psvi->cbFile > 0) && (psvi->dwCommand == 0))
|
|
{
|
|
DWORD cbSomeData;
|
|
DWORD cbRead;
|
|
|
|
cbRead = 0;
|
|
while ((psvi->cbFile > 0) && (cbRead < 1024))
|
|
{
|
|
cbSomeData = xfGetSomeData(psvi->puchBuffer+cbRead,
|
|
(unsigned short) 0x4000 - cbRead,
|
|
psvi->nSessionNumber);
|
|
|
|
if (cbSomeData > psvi->cbFile)
|
|
cbSomeData = psvi->cbFile;
|
|
|
|
psvi->cbFile -= cbSomeData;
|
|
cbRead += cbSomeData;
|
|
}
|
|
|
|
if (!WriteFile(psvi->hfile, psvi->puchBuffer, cbRead,
|
|
&cbSomeData, NULL))
|
|
{
|
|
dwReturn = GetLastError();
|
|
break;
|
|
}
|
|
|
|
psvi->cbReadTotal += cbRead;
|
|
PostMessage(hwndMain, SV_PROGRESS, 0, psvi->cbReadTotal);
|
|
}
|
|
|
|
/* caller must've signaled and waited for thread to stop */
|
|
if ((dwReturn == NO_ERROR) && (psvi->dwCommand != 0) &&
|
|
(psvi->cbFile > 0))
|
|
{
|
|
dwReturn = ERROR_OPERATION_ABORTED;
|
|
}
|
|
else if ((psvi->dwCommand == 0) || (psvi->cbFile == 0))
|
|
{
|
|
/* If thread stopped by itself, need to tell caller to kill it
|
|
* BUT ONLY if the main thread isn't tying to kill off this
|
|
* thread.
|
|
*/
|
|
if (InterlockedIncrement(&psvi->lExit) == 0)
|
|
PostMessage(hwndMain, SV_END, 0, 0L);
|
|
InterlockedDecrement( &psvi->lExit );
|
|
}
|
|
}
|
|
else if (psvi->lExit < 0)
|
|
{
|
|
/* If thread stopped by itself, need to tell caller to kill it */
|
|
PostMessage(hwndMain, SV_END, 0, 0L);
|
|
}
|
|
#endif
|
|
|
|
return dwReturn;
|
|
}
|
|
|
|
#ifdef USETCP
|
|
BOOL
|
|
FHangupConnection(WI *pwi, LPNETDATA lpData)
|
|
{
|
|
|
|
if (lpData->SessionNumber != nSessionNone)
|
|
{
|
|
if(lpData->hsd != INVALID_SOCKET)
|
|
{
|
|
closesocket( lpData->hsd );
|
|
lpData->hsd = INVALID_SOCKET;
|
|
}
|
|
lpData->SessionNumber = nSessionNone;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
#endif
|