void CNetwork::OnWinsock(WPARAM wParam, LPARAM lParam)
{
CSingleLock pLock( &m_pSection, TRUE );
LPBYTE pBuffer = NULL;
if ( ! m_pLookups.Lookup( (LPVOID)wParam, (LPVOID&)pBuffer ) ) return;
m_pLookups.RemoveKey( (LPVOID)wParam );
CString* psHost = *(CString**)pBuffer;
WORD nPort = *(WORD*)(pBuffer + 4);
BYTE nProtocol = *(BYTE*)(pBuffer + 6);
BYTE nCommand = *(BYTE*)(pBuffer + 7);
HOSTENT* pHost = (HOSTENT*)(pBuffer + 8);
if ( WSAGETASYNCERROR(lParam) == 0 )
{
if ( nCommand == 0 )
{
HostCache.ForProtocol( nProtocol )->Add( (IN_ADDR*)pHost->h_addr, nPort );
}
else
{
Neighbours.ConnectTo( (IN_ADDR*)pHost->h_addr, nPort, nProtocol, FALSE, nCommand == 2 );
}
}
else if ( nCommand > 0 )
{
theApp.Message( MSG_ERROR, IDS_NETWORK_RESOLVE_FAIL, (LPCTSTR)*psHost );
}
delete psHost;
free( pBuffer );
}
/*---------------------------------------------------
called when the window received WSOCK_GETHOST.
get IP address and send data.
---------------------------------------------------*/
void OnGetHost(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
struct hostent *pHostEnt;
unsigned long serveraddr;
if(g_hGetHost == NULL) return;
// success ?
if(WSAGETASYNCERROR(lParam) != 0)
{
SocketClose(hwnd, "failed to get IP address");
return;
}
// valid handle ?
if(g_hGetHost != (HANDLE)wParam) return;
// get IP address
pHostEnt = (struct hostent *)g_pGetHost;
serveraddr = *((unsigned long *)((pHostEnt->h_addr_list)[0]));
free(g_pGetHost); g_pGetHost = NULL;
g_hGetHost = NULL;
// send data
SNTPSend(hwnd, serveraddr);
}
int xsPalHandleGetAddrByName(UINT message, WPARAM wParam, LPARAM lParam)
{
int tagId = message - WM_XS_RESOLVE_MSG;
DWORD dwError, dwBufLen;
xsResolveTag *tag;
struct hostent *he;
xsSysEvent evt;
dwError = WSAGETASYNCERROR(lParam);
dwBufLen = WSAGETASYNCBUFLEN(lParam);
tag = &g_xsResolveTags[tagId];
he = (struct hostent *)tag->buf;
if (dwError == 0)
{
memcpy(evt.data.resolve.addr.addr.b, he->h_addr_list[0], 4);
evt.data.resolve.success = XS_TRUE;
}
else
{
evt.data.resolve.addr.addr.n = -1;
evt.data.resolve.success = XS_FALSE;
}
xsFreeNative(tag->buf);
evt.type = XS_EVT_RESOLVE;
evt.data.resolve.tag = tagId;
xsSysEventHandler(&evt);
return 0;
}
//
// Message Window Functions
//
void WAsyncSocket::GotHostByNameMessage(WPARAM wparam,LPARAM lparam)
{
int error_code=WSAGETASYNCERROR(lparam);
if(error_code!=0)
{
Close();
return;
}
sockaddr_in addr;
memset(&addr,0,sizeof(sockaddr_in));
addr.sin_family=AF_INET;
hostent *ptr=(HOSTENT *)m_hostent_buf;
addr.sin_addr.S_un.S_addr=*((unsigned long *)ptr->h_addr_list[0]);
addr.sin_port=htons(m_port);
// Connect the socket to the listening server socket
int ret=WSAConnect(m_hSocket,(sockaddr *)&addr,sizeof(sockaddr_in),NULL,NULL,NULL,NULL);
if(ret==SOCKET_ERROR)
{
int error=GetLastError();
if(error!=WSAEWOULDBLOCK)
{
#ifdef _DEBUG
char buf[128];
sprintf(buf,"WSAConnect() error %u in WAsyncSocket::GotHostByNameMessage()\n",error);
OutputDebugString(buf);
#endif
}
}
}
void XProc_DeleteCharacter::OnUserMessage_Socket( UINT message, WPARAM wparam, LPARAM lparam )
{
if (WSAGETASYNCERROR(lparam) != 0)
{
g_NetworkKernel.ProcessNetworkError();
return;
}
switch (WSAGETSELECTEVENT(lparam))
{
case FD_READ :
g_NetworkKernel.ReadSocket();
break;
case FD_CLOSE :
//_XDWINPRINT( "SERVER MESSAGE : Socket close message" );
g_NetworkKernel.ProcessNetworkError();
g_NetworkKernel.DisconnectServer();
g_NetworkKernel.ReleaseNetwork();
((CEmperorOfDragonsApp*)gApp)->m_proc_loginserver.m_PrevProcess_SelectCharacter = TRUE;
((CEmperorOfDragonsApp*)gApp)->m_ProcessManager.ChangeProcess(
&((CEmperorOfDragonsApp*)gApp)->m_proc_loginserver );
break;
}
}
LRESULT CResolver::OnResolved(WPARAM wP,LPARAM lP)
{
if(WSAGETASYNCERROR(lP))
socket->OnFailedToResolve();
else
socket->OnResolved();
return 0;
}
void CTCPClientSocketImpl::FireEvent ( bool bIsResolveEvent, uint uiResolveId, LPARAM lType )
{
// Check this is the correct thingmy #1
if ( bIsResolveEvent != m_bIsResolvingHost )
return;
// Are we resolving host? If so, we got this event from WSAAsyncGetHostByName
if ( m_bIsResolvingHost )
{
// Check this is the correct thingmy #2
if ( uiResolveId != (uint)m_pAsyncHostResolving )
return;
m_bIsResolvingHost = false;
// Get error code
unsigned short usError = WSAGETASYNCERROR ( lType );
// Succeeded? Continue
if ( !usError )
{
ConnectContinue ();
}
else
{
strcpy ( m_szLastError, "Unable to resolve" );
}
return;
}
// Check event type
switch ( WSAGETSELECTEVENT ( lType ) )
{
case FD_READ:
if ( m_pEventRead )
m_pEventRead ( this, m_pClass );
break;
case FD_WRITE:
if ( m_pEventWrite )
m_pEventWrite ( this, m_pClass );
break;
case FD_CONNECT: // Client only
if ( m_pEventConnect )
m_pEventConnect ( this, m_pClass );
break;
case FD_CLOSE:
if ( m_pEventClose )
m_pEventClose ( this, m_pClass );
break;
/*
case FD_ACCEPT: // Server only
break;
*/
}
}
void LLAsyncHostByName::handleMessage( const MSG& msg )
{
if( (HANDLE)msg.wParam != mRequestHandle )
{
llwarns << "LL_WM_HOST_RESOLVED received for request we weren't waiting for. Ignored." << llendl;
return;
}
llinfos << "LL_WM_HOST_RESOLVED" << llendl;
BOOL success = FALSE;
U32 ip = 0;
S32 error = WSAGETASYNCERROR( msg.lParam );
if( error )
{
if( error == WSANO_DATA)
{
llwarns << "Unknown host" << llendl;
}
else
{
llwarns << "Resolve host error" << WSAGetLastError () << llendl;
}
}
else
{
HOSTENT* he = (HOSTENT*) mOutputBuffer;
char** addr_list = he->h_addr_list;
if (!addr_list)
{
llwarns << "Bad HOSTENT in LLAsyncHostByName" << llendl;
return;
}
char* first_addr = addr_list[0];
if (!first_addr)
{
llwarns << "Bad address in HOSTENT in LLAsyncHostByName" << llendl;
return;
}
ip = *(U32*)first_addr;
success = TRUE;
}
if( mCallback )
{
mCallback( success, mDomainName, ip, mUserdata );
}
mCallback = NULL;
mUserdata = NULL;
mRequestHandle = 0;
mDomainName.clear();
}
//
// 함수: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// 목적: 주 창의 메시지를 처리합니다.
//
// WM_COMMAND - 응용 프로그램 메뉴를 처리합니다.
// WM_PAINT - 주 창을 그립니다.
// WM_DESTROY - 종료 메시지를 게시하고 반환합니다.
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
// 프로그램 비활성화 체크
case WM_ACTIVATEAPP :
g_bActiveApp = (BOOL)wParam;
break;
//네트워크 메시지
case WM_NETWORK :
if (WSAGETASYNCERROR(lParam))
MessageBox(g_hWnd, L"WM_NETWORK", NULL, NULL);
switch (WSAGETSELECTEVENT(lParam))
{
case FD_CONNECT :
break;
case FD_CLOSE :
MessageBox(g_hWnd, L"close", NULL, NULL);
break;
case FD_READ :
ReadProc();
break;
case FD_WRITE :
WriteProc();
break;
}
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO: 여기에 그리기 코드를 추가합니다.
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
timeBeginPeriod(1);
}
LRESULT COptionTab10::ProxySearch(int id,WPARAM wParam,LPARAM lParam) {
int errcode=WSAGETASYNCERROR(lParam);
int bufflen=WSAGETASYNCBUFLEN(lParam);
if ((id>=0) && (id<10)) {
if (!errcode) {
//HOSTENT* host=(HOSTENT*) ProxyDetectBuff[id];
//if (host->h_name) {
m_ctl_prox.AddString(ProxyDetectName[id]);
//}
}
}
return 0;
}
bool HandleMessage( UINT msg, WPARAM wParam, LPARAM lParam )
{
if( msg == WM_USER )
{
m_iResult = WSAGETASYNCERROR( lParam );
StopRunning();
return true;
}
if( msg == WM_USER+1 )
{
m_iResult = 0;
StopRunning();
return true;
}
return false;
}
void WAsyncSocket::GotHostByNameMessage(WPARAM wparam,LPARAM lparam)
{
int error_code=WSAGETASYNCERROR(lparam);
if(error_code!=0)
{
OnClose(0);
return;
}
sockaddr_in addr;
memset(&addr,0,sizeof(sockaddr_in));
addr.sin_family=AF_INET;
hostent *ptr=(HOSTENT *)m_hostent_buf;
addr.sin_addr.S_un.S_addr=*((unsigned long *)ptr->h_addr_list[0]);
addr.sin_port=htons(m_port);
// Connect the socket to the listening server socket
WSAConnect(m_hSocket,(sockaddr *)&addr,sizeof(sockaddr_in),NULL,NULL,NULL,NULL);
}
/*========================================================================================
FUNCTION: LBaseSock::WindowProc()
DESCRIPT: Event handler window procedure.
RETURN :
ARGUMENT:
uMsg : (i)Message ID
wParam: (i)Message parameter 1
lParam: (i)Message parameter 2
UPDATE : 2004/07/01, In-hyeok Paek; First work!
========================================================================================*/
LRESULT LBaseSock::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
int nErr; // Socket error code
if( uMsg == WM_SOCK_SOCKET ) {
nErr = WSAGETASYNCERROR( lParam );
switch( WSAGETSELECTEVENT( lParam ) ) {
case FD_ACCEPT:
OnAccept( nErr );
break;
case FD_CONNECT:
::KillTimer( m_hWnd, IDT_SOCK_CONNECT );
OnConnect( nErr );
break;
case FD_CLOSE:
OnClose( nErr );
break;
case FD_READ:
OnReceive( nErr );
break;
case FD_WRITE:
OnSend( nErr );
break;
}
return 0L;
}
else if( uMsg == WM_TIMER ) {
if( wParam == IDT_SOCK_CONNECT ) {
if( m_Sock != INVALID_SOCKET ) {
closesocket( m_Sock );
m_Sock = INVALID_SOCKET;
}
m_nLastErr = WSAETIMEDOUT;
OnConnect( WSAETIMEDOUT );
return 0L;
}
}
return ::DefWindowProc( m_hWnd, uMsg, wParam, lParam );
}
static LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
if(message == GETHOSTBYNAME_MSG)
{
LONG lData = GetWindowLong(hWnd, GWL_USERDATA);
wchar_t sz[100]={0};
if(lData > 0)
{
AsyncGetHostByNameData* pData = (AsyncGetHostByNameData*)lData;
int nErrorCode = WSAGETASYNCERROR(lParam);
hostent* pHostent = NULL;
if(nErrorCode == 0)
{
pHostent = (hostent*)pData->cHostent;
}
(*pData->pCallBack)((HANDLE)wParam, nErrorCode, pHostent, pData->pContext);
wsprintf(sz, L"%s_%d", GETHOSTBYNAME_WND_CLASSNAME, (int)pData->pContext);
delete pData;
}
DestroyWindow(hWnd);
UnregisterClass(sz, GetModuleHandle(0));
return 0;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
void CommOpen(HWND HW, PTTSet ts, PComVar cv)
{
#ifdef NO_INET6
int Err;
#endif /* NO_INET6 */
char ErrMsg[21+256];
char P[50+256];
MSG Msg;
#ifndef NO_INET6
ADDRINFO hints;
char pname[NI_MAXSERV];
#else
char HEntBuff[MAXGETHOSTSTRUCT];
u_long addr;
SOCKADDR_IN saddr;
#endif /* NO_INET6 */
BOOL InvalidHost;
#ifdef NO_INET6
BOOL BBuf;
#endif /* NO_INET6 */
char uimsg[MAX_UIMSG];
// ホスト名が名前付きパイプかどうかを調べる。
if (ts->PortType == IdTCPIP) {
if (CheckNamedPipeFormat(ts->HostName, strlen(ts->HostName)) == 0) {
ts->PortType = IdNamedPipe;
}
}
/* initialize ComVar */
cv->InBuffCount = 0;
cv->InPtr = 0;
cv->OutBuffCount = 0;
cv->OutPtr = 0;
cv->HWin = HW;
cv->Ready = FALSE;
cv->Open = FALSE;
cv->PortType = ts->PortType;
cv->ComPort = 0;
cv->RetryCount = 0;
#ifndef NO_INET6
cv->RetryWithOtherProtocol = TRUE;
#endif /* NO_INET6 */
cv->s = INVALID_SOCKET;
cv->ComID = INVALID_HANDLE_VALUE;
cv->CanSend = TRUE;
cv->RRQ = FALSE;
cv->SendKanjiFlag = FALSE;
cv->SendCode = IdASCII;
cv->EchoKanjiFlag = FALSE;
cv->EchoCode = IdASCII;
cv->Language = ts->Language;
cv->CRSend = ts->CRSend;
cv->KanjiCodeEcho = ts->KanjiCode;
cv->JIS7KatakanaEcho = ts->JIS7Katakana;
cv->KanjiCodeSend = ts->KanjiCodeSend;
cv->JIS7KatakanaSend = ts->JIS7KatakanaSend;
cv->KanjiIn = ts->KanjiIn;
cv->KanjiOut = ts->KanjiOut;
cv->RussHost = ts->RussHost;
cv->RussClient = ts->RussClient;
cv->DelayFlag = TRUE;
cv->DelayPerChar = ts->DelayPerChar;
cv->DelayPerLine = ts->DelayPerLine;
cv->TelBinRecv = FALSE;
cv->TelBinSend = FALSE;
cv->TelFlag = FALSE;
cv->TelMode = FALSE;
cv->IACFlag = FALSE;
cv->TelCRFlag = FALSE;
cv->TelCRSend = FALSE;
cv->TelCRSendEcho = FALSE;
cv->TelAutoDetect = ts->TelAutoDetect; /* TTPLUG */
cv->Locale = ts->Locale;
cv->locale = _create_locale(LC_ALL, cv->Locale);
cv->CodePage = &ts->CodePage;
cv->ConnetingTimeout = &ts->ConnectingTimeout;
cv->LastSendTime = time(NULL);
cv->LineModeBuffCount = 0;
cv->Flush = FALSE;
cv->FlushLen = 0;
cv->TelLineMode = FALSE;
if ((ts->PortType!=IdSerial) && (strlen(ts->HostName)==0))
{
PostMessage(cv->HWin, WM_USER_COMMNOTIFY, 0, FD_CLOSE);
return;
}
switch (ts->PortType) {
case IdTCPIP:
cv->TelFlag = (ts->Telnet > 0);
if (ts->EnableLineMode) {
cv->TelLineMode = TRUE;
}
if (! LoadWinsock()) {
if (cv->NoMsg==0) {
get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
get_lang_msg("MSG_WINSOCK_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot use winsock", ts->UILanguageFile);
MessageBox(cv->HWin,ts->UIMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
}
InvalidHost = TRUE;
}
else {
TTXOpenTCP(); /* TTPLUG */
cv->Open = TRUE;
#ifndef NO_INET6
/* resolving address */
memset(&hints, 0, sizeof(hints));
hints.ai_family = ts->ProtocolFamily;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
_snprintf_s(pname, sizeof(pname), _TRUNCATE, "%d", ts->TCPPort);
HAsync = PWSAAsyncGetAddrInfo(HW, WM_USER_GETHOST,
ts->HostName, pname, &hints, &cv->res0);
if (HAsync == 0)
InvalidHost = TRUE;
else {
cv->ComPort = 1; // set "getting host" flag
// (see CVTWindow::OnSysCommand())
do {
if (GetMessage(&Msg,0,0,0)) {
if ((Msg.hwnd==HW) &&
((Msg.message == WM_SYSCOMMAND) &&
((Msg.wParam & 0xfff0) == SC_CLOSE) ||
(Msg.message == WM_COMMAND) &&
(LOWORD(Msg.wParam) == ID_FILE_EXIT) ||
(Msg.message == WM_CLOSE))) { /* Exit when the user closes Tera Term */
PWSACancelAsyncRequest(HAsync);
CloseHandle(HAsync);
HAsync = 0;
cv->ComPort = 0; // clear "getting host" flag
PostMessage(HW,Msg.message,Msg.wParam,Msg.lParam);
return;
}
if (Msg.message != WM_USER_GETHOST) { /* Prosess messages */
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
}
else {
return;
}
} while (Msg.message!=WM_USER_GETHOST);
cv->ComPort = 0; // clear "getting host" flag
CloseHandle(HAsync);
HAsync = 0;
InvalidHost = WSAGETASYNCERROR(Msg.lParam) != 0;
}
} /* if (!LoadWinsock()) */
if (InvalidHost) {
if (cv->NoMsg==0) {
get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
get_lang_msg("MSG_INVALID_HOST_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Invalid host", ts->UILanguageFile);
MessageBox(cv->HWin,ts->UIMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
}
goto BreakSC;
}
for (cv->res = cv->res0; cv->res; cv->res = cv->res->ai_next) {
cv->s = OpenSocket(cv);
if (cv->s == INVALID_SOCKET) {
CloseSocket(cv->s);
continue;
}
/* start asynchronous connect */
AsyncConnect(cv);
break; /* break for-loop immediately */
}
break;
#else
if ((ts->HostName[0] >= 0x30) && (ts->HostName[0] <= 0x39))
{
addr = Pinet_addr(ts->HostName);
InvalidHost = (addr == 0xffffffff);
}
else {
HAsync = PWSAAsyncGetHostByName(HW,WM_USER_GETHOST,
ts->HostName,HEntBuff,sizeof(HEntBuff));
if (HAsync == 0)
InvalidHost = TRUE;
else {
cv->ComPort = 1; // set "getting host" flag
// (see CVTWindow::OnSysCommand())
do {
if (GetMessage(&Msg,0,0,0))
{
if ((Msg.hwnd==HW) &&
((Msg.message == WM_SYSCOMMAND) &&
((Msg.wParam & 0xfff0) == SC_CLOSE) ||
(Msg.message == WM_COMMAND) &&
(LOWORD(Msg.wParam) == ID_FILE_EXIT) ||
(Msg.message == WM_CLOSE)))
{ /* Exit when the user closes Tera Term */
PWSACancelAsyncRequest(HAsync);
HAsync = 0;
cv->ComPort = 0; // clear "getting host" flag
PostMessage(HW,Msg.message,Msg.wParam,Msg.lParam);
return;
}
if (Msg.message != WM_USER_GETHOST)
{ /* Prosess messages */
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
}
else {
return;
}
} while (Msg.message!=WM_USER_GETHOST);
cv->ComPort = 0; // clear "getting host" flag
HAsync = 0;
InvalidHost = WSAGETASYNCERROR(Msg.lParam) != 0;
if (! InvalidHost)
{
if (((PHOSTENT)HEntBuff)->h_addr_list != NULL)
memcpy(&addr,
((PHOSTENT)HEntBuff)->h_addr_list[0],sizeof(addr));
else
InvalidHost = TRUE;
}
}
}
if (InvalidHost)
{
if (cv->NoMsg==0) {
get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
get_lang_msg("MSG_INVALID_HOST_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Invalid host", ts->UILanguageFile);
MessageBox(cv->HWin, ts->UIMsg, uimsg, MB_TASKMODAL | MB_ICONEXCLAMATION);
}
}
else {
cv->s= Psocket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if (cv->s==INVALID_SOCKET)
{
InvalidHost = TRUE;
if (cv->NoMsg==0) {
get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
get_lang_msg("MSG_COMM_TIMEOUT_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot connect the host", ts->UILanguageFile);
MessageBox(cv->HWin, ts->UIMsg, uimsg, MB_TASKMODAL | MB_ICONEXCLAMATION);
}
}
else {
BBuf = TRUE;
Psetsockopt(cv->s,(int)SOL_SOCKET,SO_OOBINLINE,(char FAR *)&BBuf,sizeof(BBuf));
PWSAAsyncSelect(cv->s,cv->HWin,WM_USER_COMMOPEN, FD_CONNECT);
saddr.sin_family = AF_INET;
saddr.sin_port = Phtons(ts->TCPPort);
saddr.sin_addr.s_addr = addr;
memset(saddr.sin_zero,0,8);
Err = Pconnect(cv->s,(LPSOCKADDR)&saddr,sizeof(saddr));
if (Err!=0 ) Err = PWSAGetLastError();
if (Err==WSAEWOULDBLOCK )
{
/* Do nothing */
}
else if (Err!=0 )
PostMessage(cv->HWin, WM_USER_COMMOPEN,0,
MAKELONG(FD_CONNECT,Err));
}
}
}
break;
#endif /* NO_INET6 */
case IdSerial:
InitFileIO(IdSerial); /* TTPLUG */
TTXOpenFile(); /* TTPLUG */
_snprintf_s(P, sizeof(P), _TRUNCATE, "COM%d", ts->ComPort);
strncpy_s(ErrMsg, sizeof(ErrMsg),P, _TRUNCATE);
strncpy_s(P, sizeof(P),"\\\\.\\", _TRUNCATE);
strncat_s(P, sizeof(P),ErrMsg, _TRUNCATE);
cv->ComID =
PCreateFile(P,GENERIC_READ | GENERIC_WRITE,
0,NULL,OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,NULL);
if (cv->ComID == INVALID_HANDLE_VALUE ) {
get_lang_msg("MSG_CANTOEPN_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot open %s", ts->UILanguageFile);
_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, ts->UIMsg, &P[4]);
if (cv->NoMsg==0) {
get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
MessageBox(cv->HWin,ErrMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
}
InvalidHost = TRUE;
}
else {
cv->Open = TRUE;
cv->ComPort = ts->ComPort;
CommResetSerial(ts, cv, ts->ClearComBuffOnOpen);
if (!ts->ClearComBuffOnOpen) {
cv->RRQ = TRUE;
}
/* notify to VT window that Comm Port is open */
PostMessage(cv->HWin, WM_USER_COMMOPEN, 0, 0);
InvalidHost = FALSE;
SetCOMFlag(ts->ComPort);
}
break; /* end of "case IdSerial:" */
case IdFile:
InitFileIO(IdFile); /* TTPLUG */
TTXOpenFile(); /* TTPLUG */
cv->ComID = PCreateFile(ts->HostName,GENERIC_READ,0,NULL,
OPEN_EXISTING,0,NULL);
InvalidHost = (cv->ComID == INVALID_HANDLE_VALUE);
if (InvalidHost) {
if (cv->NoMsg==0) {
get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
get_lang_msg("MSG_CANTOEPN_FILE_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot open file", ts->UILanguageFile);
MessageBox(cv->HWin,ts->UIMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
}
}
else {
cv->Open = TRUE;
PostMessage(cv->HWin, WM_USER_COMMOPEN, 0, 0);
}
break;
case IdNamedPipe:
InitFileIO(IdNamedPipe); /* TTPLUG */
TTXOpenFile(); /* TTPLUG */
memset(P, 0, sizeof(P));
strncpy_s(P, sizeof(P), ts->HostName, _TRUNCATE);
// 名前付きパイプが正しい書式かをチェックする。
if (CheckNamedPipeFormat(P, strlen(P)) < 0) {
InvalidHost = TRUE;
_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE,
"Invalid pipe name\n\n"
"A valid pipe name has the form\n"
"\"\\\\<ServerName>\\pipe\\<PipeName>\"",
GetLastError());
get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
MessageBox(cv->HWin,ErrMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
break;
}
cv->ComID =
PCreateFile(P,GENERIC_READ | GENERIC_WRITE,
0,NULL,OPEN_EXISTING,
0, // ブロッキングモードにする(FILE_FLAG_OVERLAPPED は指定しない)
NULL);
if (cv->ComID == INVALID_HANDLE_VALUE ) {
get_lang_msg("MSG_CANTOEPN_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot open %s", ts->UILanguageFile);
_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, ts->UIMsg, &P[4]);
if (cv->NoMsg==0) {
get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
MessageBox(cv->HWin,ErrMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
}
InvalidHost = TRUE;
}
else {
cv->Open = TRUE;
PostMessage(cv->HWin, WM_USER_COMMOPEN, 0, 0);
InvalidHost = FALSE;
}
break; /* end of "case IdNamedPipe:" */
} /* end of "switch" */
/*
* FUNCTION: MainWndProc(HWND, UINT, WPARAM, LPARAM)
*
* PURPOSE: Processes messages
*
* MESSAGES:
*
* WM_COMMAND - application menu (About dialog box)
* WM_DESTROY - destroy window
*/
LRESULT CALLBACK
MainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
HGLOBAL hBuffer;
LPSTR lpBuffer;
int iEvent, cnt, ret;
char *tmpCommaLoc;
struct sockaddr_in remote_addr;
struct hostent *remote_host;
switch (message) {
case WM_MYSCREENCHANGEBKSP:
if (!con)
break;
con->backspace = wParam;
if (con->backspace == VK_BACK) {
con->ctrl_backspace = 0x7f;
WritePrivateProfileString(INI_TELNET, INI_BACKSPACE,
INI_BACKSPACE_BS, TELNET_INI);
}
else {
con->ctrl_backspace = VK_BACK;
WritePrivateProfileString(INI_TELNET, INI_BACKSPACE,
INI_BACKSPACE_DEL, TELNET_INI);
}
GetPrivateProfileString(INI_HOSTS, INI_HOST "0", "", buf, 128, TELNET_INI);
tmpCommaLoc = strchr(buf, ',');
if (tmpCommaLoc == NULL) {
strcat (buf, ",");
tmpCommaLoc = strchr(buf, ',');
}
if (tmpCommaLoc) {
tmpCommaLoc++;
if (con->backspace == VK_BACK)
strcpy(tmpCommaLoc, INI_HOST_BS);
else
strcpy(tmpCommaLoc, INI_HOST_DEL);
}
WritePrivateProfileString(INI_HOSTS, INI_HOST "0", buf, TELNET_INI);
break;
case WM_MYSCREENCHAR:
{
unsigned char c;
if (!con)
break;
if (wParam == VK_BACK)
c = con->backspace;
else if (wParam == 0x7f)
c = con->ctrl_backspace;
else if (wParam == VK_SPACE && GetKeyState(VK_CONTROL) < 0)
c = 0;
else
c = wParam;
TelnetSend(con->ks, &c, 1, 0);
}
break;
case WM_MYCURSORKEY:
/* Acts as a send through: buffer is lParam and length in wParam */
if (!con)
break;
memcpy(buf, (char *)lParam, wParam);
TelnetSend (con->ks, buf, wParam, 0);
break;
case WM_MYSCREENBLOCK:
if (!con)
break;
hBuffer = (HGLOBAL) wParam;
lpBuffer = GlobalLock(hBuffer);
TelnetSend(con->ks, lpBuffer, lstrlen(lpBuffer), 0);
GlobalUnlock(hBuffer);
break;
case WM_MYSCREENCLOSE:
#if 0
if (con)
{
kstream_destroy(con->ks);
con->ks = NULL;
}
#endif
DestroyWindow(hWnd);
break;
case WM_QUERYOPEN:
return(0);
break;
case WM_DESTROY: /* message: window being destroyed */
if (con)
{
kstream_destroy(con->ks);
free(con);
WSACleanup();
}
PostQuitMessage(0);
break;
case WM_NETWORKEVENT:
iEvent = WSAGETSELECTEVENT(lParam);
switch (iEvent) {
case FD_READ:
if (con == NULL)
break;
cnt = kstream_read(con->ks, buf, 1500);
buf[cnt] = 0;
parse((CONNECTION *)con, (unsigned char *)buf, cnt);
ScreenEm(buf, cnt, con->pScreen);
break;
case FD_CLOSE:
kstream_destroy(con->ks);
free(con);
con = NULL;
WSACleanup();
PostQuitMessage(0);
break;
case FD_CONNECT:
ret = WSAGETSELECTERROR(lParam);
if (ret) {
wsprintf(buf, "Error %d on Connect", ret);
MessageBox(NULL, buf, NULL, MB_OK | MB_ICONEXCLAMATION);
kstream_destroy(con->ks);
free(con);
WSACleanup();
PostQuitMessage(0);
break;
}
start_negotiation(con->ks);
break;
}
break;
case WM_HOSTNAMEFOUND:
ret = WSAGETASYNCERROR(lParam);
if (ret) {
wsprintf(buf, "Error %d on GetHostbyName", ret);
MessageBox(NULL, buf, NULL, MB_OK | MB_ICONEXCLAMATION);
kstream_destroy(con->ks);
free(con);
WSACleanup();
PostQuitMessage(0);
break;
}
remote_host = (struct hostent *)hostdata;
remote_addr.sin_family = AF_INET;
memcpy(&(remote_addr.sin_addr), &(remote_host->h_addr[0]), 4);
remote_addr.sin_port = htons(port_no);
connect(con->socket, (struct sockaddr *)&remote_addr, sizeof(struct sockaddr));
break;
case WM_MYSCREENSIZE:
con->width = LOWORD(lParam); /* width in characters */
con->height = HIWORD(lParam); /* height in characters */
if (con->bResizeable && con->ks)
send_naws(con);
wsprintf(buf, "%d", con->height);
WritePrivateProfileString(INI_TELNET, INI_HEIGHT, buf, TELNET_INI);
wsprintf(buf, "%d", con->width);
WritePrivateProfileString(INI_TELNET, INI_WIDTH, buf, TELNET_INI);
break;
default: /* Passes it on if unproccessed */
return(DefWindowProc(hWnd, message, wParam, lParam));
}
return (0);
}
BOOL
WWS32PostAsyncGetHost (
HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam
)
{
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
BOOL ret;
PVOID buffer16;
DWORD bytesRequired;
context = WWS32FindAndRemoveAsyncContext( (HANDLE)wParam );
ASSERT( context != NULL );
//
// If the call was successful, copy the 32-bit buffer to the
// 16-bit buffer specified by the application.
//
if ( WSAGETASYNCERROR( lParam ) == 0 ) {
//
// Copy the 32-bit structure to 16-bit buffer.
//
GETVDMPTR( context->vBuffer16, context->Buffer16Length, buffer16 );
bytesRequired = CopyHostent32To16(
buffer16,
context->vBuffer16,
context->Buffer16Length,
context->Buffer32
);
//
// If the application's buffer was too small, return an error
// and information aqbout the buffer size required.
//
if ( bytesRequired > context->Buffer16Length ) {
lParam = WSAMAKEASYNCREPLY( (WORD)bytesRequired, WSAENOBUFS );
}
}
//
// Post the completion message to the 16-bit application.
//
ret = PostMessage(
hWnd,
Msg >> 16,
context->AsyncTaskHandle16,
lParam
);
//
// Free resources and return.
//
free_w( context->Buffer32 );
free_w( (PVOID)context );
return ret;
} // WWS32PostAsyncGetHost
/*
* Handler for Win32 messages.
*/
static LRESULT CALLBACK
hybrid_wndproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_SOCKET:
{
fde_t *F = lookup_fd((int) wParam);
PF *hdl;
if (F != NULL && F->flags.open)
switch (WSAGETSELECTEVENT(lParam))
{
case FD_ACCEPT:
case FD_CLOSE:
case FD_READ:
if ((hdl = F->read_handler) != NULL)
{
F->read_handler = NULL;
hdl(F, F->read_data);
if (F->flags.open)
comm_setselect(F, 0, NULL, NULL, 0);
}
break;
case FD_CONNECT:
case FD_WRITE:
if ((hdl = F->write_handler) != NULL)
{
F->write_handler = NULL;
hdl(F, F->write_data);
if (F->flags.open)
comm_setselect(F, 0, NULL, NULL, 0);
}
}
return 0;
}
case WM_DNS:
{
dlink_node *ptr;
DLINK_FOREACH(ptr, dns_queries.head)
if (((struct DNSQuery *) ptr->data)->handle == wParam)
{
struct DNSQuery *query = ptr->data;
struct DNSReply *reply = NULL;
dlinkDelete(&query->node, &dns_queries);
if (WSAGETASYNCERROR(lParam) == 0)
{
struct hostent *h = (struct hostent *) &query->reply;
static struct DNSReply _reply;
reply = &_reply;
reply->h_name = h->h_name;
reply->addr.ss.ss_family = h->h_addrtype;
switch (h->h_addrtype)
{
case AF_INET:
memcpy(&((struct sockaddr_in *) &reply->addr)->sin_addr,
h->h_addr_list[0], h->h_length);
break;
#ifdef IPV6
case AF_INET6:
memcpy(&((struct sockaddr_in6 *) &reply->addr)->sin6_addr,
h->h_addr_list[0], h->h_length);
break;
#endif
default: /* shouldn't happen */
reply = NULL;
}
}
query->callback(query->ptr, reply);
return 0;
}
return 0;
}
case WM_REHASH:
dorehash = 1;
return 0;
case WM_REMOTD:
doremotd = 1;
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
}
LONG CHiddenFrame::OnFoundDNS(WPARAM wParam, LONG lParam)
{
int iError = WSAGETASYNCERROR(lParam);
// Go through the DNS cache, find the correct task ID.
// The find should always be successful.
// Be sure to initalize values.
POSITION pos = NULL;
CString key;
CDNSObj *obj = NULL;
int i_found = 0;
LONG return_value = 1;
for(pos = DNSCacheMap.GetStartPosition(); pos != NULL;) {
DNSCacheMap.GetNextAssoc(pos, key, (CObject *&)obj);
if(!obj)
return return_value;
// Since the handle is not unique for the session only
// compare handles that are currently in use (i.e. active entries)
if(!obj->i_finished && obj->m_handle == (HANDLE)wParam) {
i_found = 1;
break;
}
// Clear out object if we didn't break.
// That way we don't retain value if we leave the loop.
obj = NULL;
}
if(!obj)
return return_value;
TRACE("%s error=%d h_name=%d task=%d\n", obj->m_host, iError,
(obj->m_hostent->h_name != NULL) ? 1 : 0, obj->m_handle);
// If by chance we couldn't find it, we have a problem.
//
ASSERT(i_found == 1);
/* temp fix */
if(!i_found)
return return_value;
// Mark this as completed.
//
obj->i_finished = 1;
// If there was an error, set it.
if (iError) {
TRACE("DNS Lookup failed! \n");
obj->m_iError = iError;
return_value = 0;
}
/* call ProcessNet for each socket in the list */
/* use a for loop so that we don't reference the "obj"
* after our last call to processNet. We need to do
* this because the "obj" can get free'd by the call
* chain after all the sockets have been removed from
* sock_list
*/
PRFileDesc *tmp_sock;
int count = XP_ListCount(obj->m_sock_list);
for(; count; count--) {
tmp_sock = (PRFileDesc *) XP_ListRemoveTopObject(obj->m_sock_list);
// Make sure we call into the Netlib on this socket in particular,
// NET_SOCKET_FD type.
OnForceIOSelect((WPARAM)SocketSelect, (LPARAM)tmp_sock);
}
return(return_value);
}
void CServerSocet::AddClient(LPARAM lParam)
{
try
{
if (sokClientSocket == NULL)
{
WriteToLog(_T("Не инициализированы клиенты"));
return;
}
int i;
i=0;
while (sokClientSocket[i]!=NULL)
{
if(sokClientSocket[i]->sUserIP != _T(""))
i++;
else
break;
}
if (i >= iMaxCol)
{
WriteToLog(_T("Привышенно колличество клиентов!"));
return;
}
if (WSAGETASYNCERROR(lParam))
{
return;
}
if (WSAGETSELECTEVENT(lParam) == FD_ACCEPT)
{
int length=sizeof(SOCKADDR);
SOCKADDR_IN socketclientaddr;
if(sokClientSocket[i]->sok == NULL)
{
sokClientSocket[i]->sok = new SOCKET;
}
*sokClientSocket[i]->sok=accept(sokServerSocket,(LPSOCKADDR)&socketclientaddr, (LPINT) &length);
socketclientaddr.sin_addr;
CString sIP;
sIP=inet_ntoa(socketclientaddr.sin_addr);
int j=0;
while(iMaxCol>j)
{
if(sokClientSocket[j]->sUserIP == sIP)
{
if(sokClientSocket[j]->dBase != NULL)
{
if(sokClientSocket[j]->dBase->IsOpen())
sokClientSocket[j]->dBase->Close();
delete(sokClientSocket[j]->dBase);
sokClientSocket[j]->dBase = NULL;
}
if(sokClientSocket[j]->hThread != 0)
{
TerminateThread(sokClientSocket[j]->hThread,0);
}
if(sokClientSocket[j]->sok != NULL)
{
shutdown(*sokClientSocket[j]->sok, 0);
LINGER linger = { 1, 0 };
setsockopt(*sokClientSocket[j]->sok, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
closesocket(*sokClientSocket[j]->sok);
delete(sokClientSocket[j]->sok);
sokClientSocket[j]->sok = NULL;
}
sokClientSocket[j]->sUserIP = _T("");
}
j++;
}
sokClientSocket[i]->sUserIP = sIP;
if (*sokClientSocket[i]->sok == INVALID_SOCKET)
{
return;
}
DWORD dwThreadID;
CurrSocet* stCurrSocet;
stCurrSocet = new CurrSocet;
stCurrSocet->sSocet = this;
stCurrSocet->CurrPos = i;
if(sokClientSocket[i]->dBase == NULL)
sokClientSocket[i]->dBase = new(CDatabase);
sokClientSocket[i]->hThread = CreateThread (NULL, NULL, (LPTHREAD_START_ROUTINE)*m_ClientTread, (void*)stCurrSocet, NULL, &dwThreadID);
}
}
catch(CException *except)
{
CString sError;
except->GetErrorMessage((LPTSTR)&sError,255,0);
except->Delete();
WriteToLog(sError);
}
}
long WINAPI InterfaceWindowProc(HWND hwnd,UINT message,UINT wParam,LONG lParam)
{
char buf[40];
switch (message)
{
case WM_CREATE :
InterfaceCreate(hwnd,wParam,lParam);
break;
HANDLE_MSG(hwnd,WM_COMMAND,InterfaceCommand);
case WM_DESTROY :
SetQuit();
PostQuitMessage(0);
return 0;
case WM_CLOSE :
if (MessageBox(hwnd,"Are you sure you want to exit?",BlakServNameString(),
MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION) == IDYES)
{
DestroyWindow(hwnd);
}
break;
case WM_TIMER :
KillTimer(hwndMain,WIN_TIMER_ID);
SendDlgItemMessage(hwndMain,IDS_STATUS_WINDOW,SB_SETTEXT,0,(LPARAM)"");
break;
case WM_NOTIFY:
switch (((LPNMHDR) lParam)->code)
{
case TTN_NEEDTEXT:
{
LPTOOLTIPTEXT lpttt;
lpttt = (LPTOOLTIPTEXT) lParam;
lpttt->hinst = hInst;
/* Specify the resource identifier of the descriptive
text for the given button. */
switch (lpttt->hdr.idFrom)
{
case IDM_FILE_EXIT :
lpttt->lpszText = "Exit";
break;
case IDM_FILE_SAVE :
lpttt->lpszText = "Save Game";
break;
case IDM_FILE_RELOADSYSTEM :
lpttt->lpszText = "Reload System";
break;
case IDM_MESSAGES_MESSAGEOFTHEDAY :
lpttt->lpszText = "Message of the Day";
break;
case IDM_HELP_ABOUT :
lpttt->lpszText = "About";
break;
}
break;
}
break;
case TCN_SELCHANGE :
InterfaceTabChange();
break;
case TCN_SELCHANGING :
return FALSE; /* means we'll allow it to change */
break;
}
break;
case WM_BLAK_NEW_INFO :
InterfaceDrawText(hwnd);
break;
case WM_BLAK_LOGON :
sessions_logged_on++;
/*
sprintf(buf,"Connections: %i",sessions_logged_on);
SetDlgItemText(HWND_STATUS,IDC_CONNECTIONS_BORDER,buf);
*/
sprintf(buf,"%3i",sessions_logged_on);
SendDlgItemMessage(hwndMain,IDS_STATUS_WINDOW,SB_SETTEXT,1,(LPARAM)buf);
InterfaceAddList(lParam);
break;
case WM_BLAK_LOGOFF :
sessions_logged_on--;
if (sessions_logged_on < 0)
eprintf("InterfaceWindowProc sessions_logged_on just went negative!\n");
/*
sprintf(buf,"Connections: %i",sessions_logged_on);
SetDlgItemText(HWND_STATUS,IDC_CONNECTIONS_BORDER,buf);
*/
sprintf(buf,"%3i",sessions_logged_on);
SendDlgItemMessage(hwndMain,IDS_STATUS_WINDOW,SB_SETTEXT,1,(LPARAM)buf);
InterfaceRemoveList(lParam);
break;
case WM_BLAK_UPDATE_SESSION :
InterfaceUpdateList(lParam);
break;
case WM_BLAK_UPDATE_CHANNEL :
InterfaceCheckChannels();
break;
case WM_BLAK_UPDATE_ADMIN :
InterfaceUpdateAdmin();
break;
case WM_BLAK_SIGNAL_CONSOLE :
if (PlaySound("signal",hInst,SND_RESOURCE | SND_ASYNC) == FALSE)
{
MessageBeep(MB_OK);
break;
}
FlashWindow(hwnd,TRUE);
Sleep(200);
FlashWindow(hwnd,TRUE);
break;
case WM_BLAK_SOCKET_ACCEPT :
AsyncSocketAccept(wParam,WSAGETSELECTEVENT(lParam),WSAGETSELECTERROR(lParam),
SOCKET_PORT);
break;
case WM_BLAK_SOCKET_MAINTENANCE_ACCEPT :
AsyncSocketAccept(wParam,WSAGETSELECTEVENT(lParam),WSAGETSELECTERROR(lParam),
SOCKET_MAINTENANCE_PORT);
break;
case WM_BLAK_SMTP_SOCKET_ACCEPT :
AsyncSMTPSocketAccept(wParam,WSAGETSELECTEVENT(lParam),WSAGETSELECTERROR(lParam));
break;
case WM_BLAK_SOCKET_NAME_LOOKUP :
AsyncNameLookup((HANDLE)wParam,WSAGETASYNCERROR(lParam));
break;
case WM_BLAK_SOCKET_SELECT :
AsyncSocketSelect(wParam,WSAGETSELECTEVENT(lParam),WSAGETSELECTERROR(lParam));
break;
default :
return DefWindowProc(hwnd,message,wParam,lParam);
}
return TRUE;
}
// Message handler for PWM_ASYNC_DNS
// Notifies the client win_net object that DNS has completed or
// returned w/ an error.
LRESULT CAsyncSockN::OnAsyncDNS(WPARAM wParam, LPARAM lParam)
{
void* handle = (void*) (HANDLE) wParam;
void* pVoid = 0;
win_net* pClient = 0;
DNS_REQUEST* pDNSRequest = NULL;
// Bail if the client map has been previously deleted, this
// is a sure sign of us already being cleaned up!
if(!m_ClientHandlesMap)
{
return(TRUE);
}
DEBUGOUTSTR( "AsyncDNS come back\r\n" );
// Based on the handle returned, find our client!
// Note it might be missing from the map if we canceled
// the DNS!
if (m_ClientHandlesMap->Lookup(handle, pVoid))
{
*((ULONG32 *)&pClient) = (ULONG32)pVoid;
// We should already have an async operation active on this socket!
#ifdef _DEBUG
if ((void *)pClient->m_hAsyncHandle != handle)
{
char szMessage[256]; /* Flawfinder: ignore */
sprintf(szMessage,"pClient->m_hAsyncHandle = %#lx\nhandle = %#lx", /* Flawfinder: ignore */
pClient->m_hAsyncHandle,
handle
);
MessageBox(NULL,szMessage,"Oops!",MB_OK);
}
HX_ASSERT((void *)pClient->m_hAsyncHandle == handle);
#endif
// Tell win_net object to forget the Async handle
pClient->m_hAsyncHandle = NULL;
pClient->CB_DNSComplete(!WSAGETASYNCERROR(lParam));
// If async DNS is done, then we can forget the Async handle
if (m_ClientHandlesMap->RemoveKey(handle))
{
DecrementHandlesClientCount();
}
}
#ifdef _DEBUG
if (m_ClientHandlesMap->GetCount() != m_cbNumHandlesClients)
{
char szMessage[256]; /* Flawfinder: ignore */
sprintf(szMessage,"m_ClientHandlesMap->GetCount() = %d\nm_cbNumHandlesClients = %d", /* Flawfinder: ignore */
m_ClientHandlesMap->GetCount(),
m_cbNumHandlesClients
);
MessageBox(NULL,szMessage,"Oops!",MB_OK);
}
HX_ASSERT(m_ClientHandlesMap->GetCount() == m_cbNumHandlesClients);
#endif
if (sockGlobals.m_bWinSock2Suck)
{
pDNSRequest = (DNS_REQUEST*) sockGlobals.m_DNSQueue.RemoveHead();
HX_DELETE(pDNSRequest);
}
// check to see if we are still in use.
CheckClients();
return (TRUE);
}
// ウィンドウメッセージを処理してデータを受信する
// 受信データはrecvBufに追記される
// 戻り値: 負値=切断した(-2=正常,-1=中断), 0=正常に処理した
int CAsyncSocket::ProcessRecv(WPARAM wParam, LPARAM lParam, std::vector<char> *recvBuf)
{
UINT imAddr = INADDR_NONE;
if (bReady_) {
// 待機中
if (wParam || lParam) {
return 0;
}
bReady_ = false;
if (bShutdown_) {
bShutdown_ = false;
return -1;
}
if ((imAddr = inet_addr(name_)) == INADDR_NONE) {
hGethost_ = WSAAsyncGetHostByName(hwnd_, msg_, name_, hostBuf_, sizeof(hostBuf_));
return hGethost_ ? 0 : -1;
}
// IPアドレス即値(名前解決を省略)
} else if (hGethost_) {
// 名前解決中
bool bValid = wParam == (WPARAM)hGethost_ && WSAGETASYNCERROR(lParam) == 0;
hGethost_ = NULL;
if (bShutdown_) {
bShutdown_ = false;
return -1;
}
if (!bValid || (imAddr = *(UINT*)((HOSTENT*)hostBuf_)->h_addr) == INADDR_NONE) {
return -1;
}
}
if (imAddr != INADDR_NONE) {
// 接続
if ((soc_ = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
return -1;
}
WSAAsyncSelect(soc_, hwnd_, msg_, FD_WRITE | FD_READ | FD_CLOSE);
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = imAddr;
addr.sin_port = htons(port_);
if (connect(soc_, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK) {
closesocket(soc_);
soc_ = INVALID_SOCKET;
return -1;
}
return 0;
}
if (soc_ != INVALID_SOCKET) {
// 送受信中
if (wParam == (WPARAM)soc_) {
switch(WSAGETSELECTEVENT(lParam)) {
case FD_WRITE:
if (!bShutdown_) {
while (!sendBuf_.empty()) {
int wrote = send(soc_, &sendBuf_.front(), (int)sendBuf_.size(), 0);
if (wrote == SOCKET_ERROR) {
// WSAEWOULDBLOCK時はつぎのFD_WRITEに先送り
if (WSAGetLastError() != WSAEWOULDBLOCK) {
Shutdown();
}
break;
}
sendBuf_.erase(sendBuf_.begin(), sendBuf_.begin() + wrote);
}
if (sendBuf_.empty() && !bKeepSession_ && bDoHalfClose_) {
// ハーフクローズ
// Bitdefender環境で受信が中断する不具合を確認(2013-10-28)
shutdown(soc_, SD_SEND);
}
}
return 0;
case FD_READ:
for (;;) {
char buf[2048];
int read = recv(soc_, buf, sizeof(buf), 0);
if (read == SOCKET_ERROR || read <= 0) {
// FD_CLOSEで拾うので無視
return 0;
}
recvBuf->insert(recvBuf->end(), &buf[0], &buf[read]);
}
break;
case FD_CLOSE:
if (WSAGETSELECTERROR(lParam) != 0) {
Close();
return -1;
}
for (;;) {
char buf[2048];
int read = recv(soc_, buf, sizeof(buf), 0);
if (read == SOCKET_ERROR || read <= 0) {
Close();
return read == 0 ? -2 : -1;
}
recvBuf->insert(recvBuf->end(), &buf[0], &buf[read]);
}
break;
}
}
return 0;
}
return -1;
}
