BOOL LLAsyncHostByName::startRequest( const LLString& domain_name, LLAsyncHostByNameCallback callback, void* userdata )
{
if( isPendingRequest() )
{
llwarns << "LLAsyncHostByName::startRequest() cancelled existing request." << llendl;
cancelPendingRequest();
}
mCallback = callback;
mUserdata = userdata;
memset(mOutputBuffer, 0, sizeof( mOutputBuffer ) );
mDomainName = domain_name;
mRequestHandle = WSAAsyncGetHostByName(
(HWND)gViewerWindow->getPlatformWindow(),
LL_WM_HOST_RESOLVED,
domain_name.c_str(),
mOutputBuffer,
sizeof( mOutputBuffer ) );
if( !mRequestHandle )
{
llwarns << "LLAsyncHostByName::startRequest() failed: " << WSAGetLastError() << llendl;
return FALSE;
}
return TRUE;
}
HANDLE AsyncGetHostByName(const char* pHostName, void* pContext, GETHOSTBYNAME_CALLBACK pCallBack)
{
WNDCLASSEX wndclass;
wndclass.cbSize = sizeof wndclass;
wndclass.style = 0;
wndclass.lpfnWndProc = WindowProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = GetModuleHandle(0);
wndclass.hIcon = 0;
wndclass.hCursor = 0;
wndclass.hbrBackground = 0;
wndclass.lpszMenuName = 0;
wchar_t sz[100]={0};
wsprintf(sz, L"%s_%d", GETHOSTBYNAME_WND_CLASSNAME, (int)pContext);
wndclass.lpszClassName = sz;
wndclass.hIconSm = 0;
if(RegisterClassEx(&wndclass))
{
AsyncGetHostByNameData* pData = new AsyncGetHostByNameData;
memset(&pData->cHostent, 0, sizeof(pData->cHostent));
pData->pCallBack = pCallBack;
pData->pContext = pContext;
HWND hWnd = CreateWindow(sz, sz, 0, 0, 0, 0, 0, 0, 0, 0, GetModuleHandle(0));
SetWindowLong(hWnd, GWL_USERDATA, (LONG)pData);
return WSAAsyncGetHostByName(hWnd, GETHOSTBYNAME_MSG, pHostName, pData->cHostent, MAXGETHOSTSTRUCT);
}
return 0;
}
int WAsyncSocket::Connect(char *host,unsigned int port)
{
m_port=port;
// Check to see if we need to get the ip address from the host address
bool is_ip_string=false;
unsigned int ip_int[4];
if(sscanf(host,"%u.%u.%u.%u",&ip_int[0],&ip_int[1],&ip_int[2],&ip_int[3])==4)
{
is_ip_string=true;
}
// If this is not an ip string we are connecting to, then resolve the hosts ip address from the DNS
if(is_ip_string==false)
{
WSAAsyncGetHostByName(m_hwnd,WM_GOT_HOST_BY_NAME_MESSAGE,host,m_hostent_buf,sizeof(m_hostent_buf));
}
else // it is just an IP
{
unsigned long ip_addr=inet_addr(host);
WSAAsyncGetHostByAddr(m_hwnd,WM_GOT_HOST_BY_ADDRESS_MESSAGE,(char *)&ip_addr,sizeof(unsigned long),AF_INET,
m_hostent_buf,sizeof(m_hostent_buf));
}
return 0;
}
BOOL CNetwork::AsyncResolve(LPCTSTR pszAddress, WORD nPort, PROTOCOLID nProtocol, BYTE nCommand)
{
CSingleLock pLock( &m_pSection );
if ( ! pLock.Lock( 250 ) ) return FALSE;
BYTE* pResolve = (BYTE*)malloc( MAXGETHOSTSTRUCT + 8 );
USES_CONVERSION;
HANDLE hAsync = WSAAsyncGetHostByName( AfxGetMainWnd()->GetSafeHwnd(), WM_WINSOCK,
T2CA(pszAddress), (LPSTR)pResolve + 8, MAXGETHOSTSTRUCT );
if ( hAsync != NULL )
{
*((CString**)&pResolve[0]) = new CString( pszAddress );
*((WORD*)&pResolve[4]) = nPort;
*((BYTE*)&pResolve[6]) = nProtocol;
*((BYTE*)&pResolve[7]) = nCommand;
m_pLookups.SetAt( (LPVOID)hAsync, (LPVOID)pResolve );
return TRUE;
}
else
{
free( pResolve );
return FALSE;
}
}
*/ DEVICE_CMD Read_DNS(REBREQ *sock)
/*
** Initiate the GetHost request and return immediately.
** Note the temporary results buffer (must be freed later).
**
***********************************************************************/
{
void *host;
#ifdef HAS_ASYNC_DNS
HANDLE handle;
#else
HOSTENT *he;
#endif
host = OS_Make(MAXGETHOSTSTRUCT); // be sure to free it
#ifdef HAS_ASYNC_DNS
if (!GET_FLAG(sock->modes, RST_REVERSE)) // hostname lookup
handle = WSAAsyncGetHostByName(Event_Handle, WM_DNS, sock->data, host, MAXGETHOSTSTRUCT);
else
handle = WSAAsyncGetHostByAddr(Event_Handle, WM_DNS, (char*)&(sock->net.remote_ip), 4, AF_INET, host, MAXGETHOSTSTRUCT);
if (handle != 0) {
sock->net.host_info = host;
sock->handle = handle;
return DR_PEND; // keep it on pending list
}
#else
// Use old-style blocking DNS (mainly for testing purposes):
if (GET_FLAG(sock->modes, RST_REVERSE)) {
he = gethostbyaddr((char*)&sock->net.remote_ip, 4, AF_INET);
if (he) {
sock->net.host_info = host; //???
sock->data = he->h_name;
SET_FLAG(sock->flags, RRF_DONE);
return DR_DONE;
}
}
else {
he = gethostbyname(sock->data);
if (he) {
sock->net.host_info = host; // ?? who deallocs?
COPY_MEM((char*)&(sock->net.remote_ip), (char *)(*he->h_addr_list), 4); //he->h_length);
SET_FLAG(sock->flags, RRF_DONE);
return DR_DONE;
}
}
#endif
OS_Free(host);
sock->net.host_info = 0;
sock->error = GET_ERROR;
//Signal_Device(sock, EVT_ERROR);
return DR_ERROR; // Remove it from pending list
}
void
gethost_byname(const char *name, struct DNSQuery *query)
{
query->handle = WSAAsyncGetHostByName(wndhandle, WM_DNS, name, query->reply,
sizeof(query->reply));
if (!query->handle)
query->callback(query->ptr, NULL);
else
dlinkAdd(query, &query->node, &dns_queries);
}
int CSock::Connect(const char *address, unsigned short port, UINT host_found_msg)
{
unsigned long addr=inet_addr(address);
if( INADDR_NONE == addr && host_found_msg)
{
m_GetHostBuf = new char[MAXGETHOSTSTRUCT];
m_GetHostTask = WSAAsyncGetHostByName( m_SinkWnd, host_found_msg, address, m_GetHostBuf, MAXGETHOSTSTRUCT );
return 0;
}
return DoConnect(addr);
}
int CResolver::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CWnd::OnCreate(lpCreateStruct) == -1)
return -1;
ASSERT(socket);
CString hostName = socket->m_HostName;
int at = hostName.Find('@');
if(at>=0)
hostName=hostName.Mid(at+1);
m_hAsync=WSAAsyncGetHostByName(m_hWnd,WM_RESOLVED,(LPCTSTR)hostName,(char*)socket->m_ResolveBuff,sizeof(socket->m_ResolveBuff));
ASSERT(m_hAsync);
return 0;
}
/*
* The WINSOCK routine gethostbyname has a bug in both FTP and NetManage
* implementations which causes the blocking hook, if any, not to be
* called. This routine attempts to work around the problem by using
* the async routines to emulate the functionality of the synchronous
* routines
*/
struct hostent *PASCAL
krb_gethostbyname(
const char *name)
{
HWND hwnd;
char buf[MAXGETHOSTSTRUCT];
BOOL FARPROC blockinghook;
WNDCLASS wc;
static BOOL isregistered;
blockinghook = WSASetBlockingHook(NULL);
WSASetBlockingHook(blockinghook);
if (blockinghook == NULL)
return gethostbyname(name);
if (RegisterWndClass() == NULL)
return gethostbyname(name);
if (!isregistered) {
wc.style = 0;
wc.lpfnWndProc = gethostbyname_wnd_proc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hlibinstance;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = GETHOSTBYNAME_CLASS;
if (!RegisterClass(&wc))
return gethostbyname(name);
isregistered = TRUE;
}
hwnd = CreateWindow(GETHOSTBYNAME_CLASS, "", WS_OVERLAPPED,
-100, -100, 0, 0, HWND_DESKTOP, NULL, hlibinstance, NULL);
if (hwnd == NULL)
return gethostbyname(name);
htaskasync =
WSAAsyncGetHostByName(hwnd, WM_ASYNC_COMPLETED, name, buf, sizeof(buf));
b = blockinghook(NULL);
}
/*---------------------------------------------------
start SNTP session
---------------------------------------------------*/
BOOL SNTPStart(HWND hwndSNTP)
{
char servername[BUFSIZE_SERVER];
unsigned long serveraddr;
if(m_socket != INVALID_SOCKET || m_hGetHost != NULL) return FALSE;
// get server name and port
m_port = GetServerPort(m_servername, servername);
if(m_port == -1)
{
Log(hwndSNTP, "invalid server name"); return FALSE;
}
// make a socket
m_socket = socket(PF_INET, SOCK_DGRAM, 0);
if(m_socket == INVALID_SOCKET)
{
Log(hwndSNTP, "socket() failed");
return FALSE;
}
serveraddr = inet_addr(servername);
// if server name is not "XXX.XXX.XXX.XXX"
if(serveraddr == INADDR_NONE)
{
// request IP address
m_pGetHost = malloc(MAXGETHOSTSTRUCT);
m_hGetHost = WSAAsyncGetHostByName(hwndSNTP, WSOCK_GETHOST,
servername, m_pGetHost, MAXGETHOSTSTRUCT);
if(m_hGetHost == NULL)
{
free(m_pGetHost); m_pGetHost = NULL;
SocketClose(hwndSNTP, "WSAAsyncGetHostByName() failed");
return FALSE;
}
return TRUE;
}
// send data
SNTPSend(hwndSNTP, serveraddr);
return TRUE;
}
/*---------------------------------------------------
start SNTP session
---------------------------------------------------*/
void SNTPStart(HWND hwnd, char *buf)
{
char servername[256];
unsigned long serveraddr;
if(g_socket != -1 || g_hGetHost != NULL) return;
// get server name and port
g_port = GetServerPort(buf, servername);
if(g_port == -1)
{
Log("invalid server name"); return;
}
// make a socket
g_socket = socket(PF_INET, SOCK_DGRAM, 0);
if(g_socket == INVALID_SOCKET)
{
Log("socket() failed");
g_socket = (SOCKET)-1; return;
}
serveraddr = inet_addr((char*)servername);
// if server name is not "XXX.XXX.XXX.XXX"
if(serveraddr == -1)
{
// request IP address
g_pGetHost = malloc(MAXGETHOSTSTRUCT);
g_hGetHost = WSAAsyncGetHostByName(hwnd, WSOCK_GETHOST,
servername, g_pGetHost, MAXGETHOSTSTRUCT);
if(g_hGetHost == 0)
{
SocketClose(hwnd, "WSAAsyncGetHostByName() failed");
return;
}
dwTickCountOnGetHost = GetTickCount();
return;
}
// send data
SNTPSend(hwnd, serveraddr);
}
*/ DEVICE_CMD Read_DNS(REBREQ *sock)
/*
** Initiate the GetHost request and return immediately.
** Note the temporary results buffer (must be freed later).
**
***********************************************************************/
{
char *host;
#ifdef HAS_ASYNC_DNS
HANDLE handle;
#else
HOSTENT *he;
#endif
host = OS_ALLOC_ARRAY(char, MAXGETHOSTSTRUCT); // be sure to free it
#ifdef HAS_ASYNC_DNS
if (!GET_FLAG(sock->modes, RST_REVERSE)) // hostname lookup
handle = WSAAsyncGetHostByName(Event_Handle, WM_DNS, s_cast(sock->common.data), host, MAXGETHOSTSTRUCT);
else
handle = WSAAsyncGetHostByAddr(Event_Handle, WM_DNS, s_cast(&sock->special.net.remote_ip), 4, AF_INET, host, MAXGETHOSTSTRUCT);
if (handle != 0) {
sock->special.net.host_info = host;
sock->requestee.handle = handle;
return DR_PEND; // keep it on pending list
}
#else
// Use old-style blocking DNS (mainly for testing purposes):
if (GET_FLAG(sock->modes, RST_REVERSE)) {
he = gethostbyaddr(
cast(char*, &sock->special.net.remote_ip), 4, AF_INET
);
if (he) {
sock->special.net.host_info = host; //???
sock->common.data = b_cast(he->h_name);
SET_FLAG(sock->flags, RRF_DONE);
return DR_DONE;
}
}
int xsGetAddrByName(const char *hostname, xsSockAddr *addr, int tag)
{
char *buf;
UINT message = WM_XS_RESOLVE_MSG + tag;
if (message > WM_XS_RESOLVE_MSG_END)
return XS_EC_NOMEM;
buf = (char *)xsMallocNative(MAXGETHOSTSTRUCT);
if (buf == NULL)
return XS_EC_NOMEM;
g_xsResolveTags[tag].buf = buf;
g_xsResolveTags[tag].handle = WSAAsyncGetHostByName(g_hMainWnd, message, hostname, buf, MAXGETHOSTSTRUCT);
if (g_xsResolveTags[tag].handle == NULL)
{
int error = WSAGetLastError();
XS_ERROR("[PAL]xsGetAddrByName: code:%d", error);
return XS_EC_ERROR;
}
return XS_EC_IN_PROGRESS;
}
bool CTCPClientSocketImpl::Connect ( const char* szHost, unsigned short usPort )
{
// Save the port
m_usPort = usPort;
// If we're already connected, disconnect
if ( m_bIsConnected )
{
Disconnect ();
}
// If we have active host resolving, cancel it
if ( m_bIsResolvingHost )
{
WSACancelAsyncRequest ( m_pAsyncHostResolving );
}
// Got a socket?
if ( !m_Socket )
{
// No socket
strcpy ( m_szLastError, "No socket initialized" );
return false;
}
// Start async resolving it
m_pAsyncHostResolving = WSAAsyncGetHostByName ( CCore::GetSingleton ().GetHookedWindow (), WM_ASYNCTRAP + m_uiID + 256, szHost, m_pHostInfo, MAXGETHOSTSTRUCT );
if ( !m_pAsyncHostResolving )
{
// Failed
strcpy ( m_szLastError, "Unable to start resolving" );
return false;
}
m_bIsResolvingHost = true;
return true;
}
BOOL COptionTab10::OnInitDialog()
{
CPropertyPage::OnInitDialog();
EnableToolTips(true); // TOOL TIPS
/* hide password */
CString st;
GetDlgItemText(IDC_prox,st);
if (st.Find('@')>=0) {
m_ctl_pwdhide.SetCheck(1);
OnPwdhide();
} else {
m_ctl_pwdhide.SetCheck(0);
OnPwdhide();
}
if (LANG_T(-1)) { // Patcher en français
SetDlgItemTextCP(this, IDC_proxyconfigure,LANG(LANG_I47b)); // "Configurer"
SetDlgItemTextCP(this, IDC_ftpprox,LANG(LANG_I47c));
SetDlgItemTextCP(this, IDC_PWDHIDE,LANG_HIDEPWD); /* Hide password */
}
// mode modif à la volée
if (modify==1) {
GetDlgItem(IDC_prox ) ->ModifyStyle(0,WS_DISABLED);
GetDlgItem(IDC_portprox ) ->ModifyStyle(0,WS_DISABLED);
GetDlgItem(IDC_proxyconfigure ) ->ModifyStyle(0,WS_DISABLED);
GetDlgItem(IDC_proxtitle ) ->ModifyStyle(0,WS_DISABLED);
GetDlgItem(IDC_ftpprox ) ->ModifyStyle(0,WS_DISABLED);
} else {
GetDlgItem(IDC_prox ) ->ModifyStyle(WS_DISABLED,0);
GetDlgItem(IDC_portprox ) ->ModifyStyle(WS_DISABLED,0);
GetDlgItem(IDC_proxyconfigure ) ->ModifyStyle(WS_DISABLED,0);
GetDlgItem(IDC_proxtitle ) ->ModifyStyle(WS_DISABLED,0);
GetDlgItem(IDC_ftpprox ) ->ModifyStyle(WS_DISABLED,0);
}
CString str;
GetDlgItemText(IDC_prox,str);
m_ctl_prox.ResetContent();
m_ctl_prox.AddString("");
HKEY phkResult;
if (RegOpenKeyEx(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",0,KEY_READ,&phkResult)==ERROR_SUCCESS) {
DWORD type=0;
DWORD datasize=1000;
char data[1024];
data[0]='\0';
if (RegQueryValueEx(phkResult,"ProxyServer",0,&type,(unsigned char*)&data,&datasize)==ERROR_SUCCESS) {
if (datasize) {
char* a=strchr(data,':');
if (a)
*a='\0';
m_ctl_prox.AddString(data);
}
}
RegCloseKey(phkResult);
}
SetDlgItemTextCP(this, IDC_prox,str);
// Do not search for a proxy everytime
CWinApp* pApp = AfxGetApp();
if (pApp->GetProfileInt("Interface","FirstProxySearch",0) != 1) {
pApp->WriteProfileInt("Interface","FirstProxySearch",1);
// Launch proxy name search
int i=0;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="proxy") ,this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="www") ,this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="ns") ,this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="web") ,this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="ntserv") ,this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="gate") ,this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="gateway") ,this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="firewall"),this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
WSAAsyncGetHostByName(this->m_hWnd,wm_ProxySearch+i,(ProxyDetectName[i]="cache") ,this->ProxyDetectBuff[i],sizeof(this->ProxyDetectBuff[i])); i++;
}
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
int
OpenTelnetConnection(void)
{
int nReturn, ret;
struct sockaddr_in sockaddr;
char *p;
static struct kstream_crypt_ctl_block ctl;
char buf[128];
tmpConfig = calloc(sizeof(CONFIG), 1);
if (bAutoConnection) {
tmpConfig->title = calloc(lstrlen(szHostName), 1);
lstrcpy(tmpConfig->title, (char *) szHostName);
} else {
nReturn = DoDialog("OPENTELNETDLG", OpenTelnetDlg);
if (nReturn == FALSE)
return(FALSE);
}
con = (CONNECTION *) GetNewConnection();
if (con == NULL)
return(0);
tmpConfig->width =
GetPrivateProfileInt(INI_TELNET, INI_WIDTH, DEF_WIDTH, TELNET_INI);
tmpConfig->height =
GetPrivateProfileInt(INI_TELNET, INI_HEIGHT, DEF_HEIGHT, TELNET_INI);
con->width = tmpConfig->width;
con->height = tmpConfig->height;
con->backspace = SaveHostName(tmpConfig->title, port_no);
if (con->backspace == VK_BACK) {
tmpConfig->backspace = TRUE;
con->ctrl_backspace = 0x7f;
} else {
tmpConfig->backspace = FALSE;
con->ctrl_backspace = 0x08;
}
tmpConfig->hwndTel = hWnd;
con->pScreen = InitNewScreen(tmpConfig);
if (!con->pScreen) {
assert(FALSE);
free(con->pScreen);
free(con);
free(tmpConfig);
return(-1);
}
ret = (SOCKET) socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (ret == SOCKET_ERROR) {
wsprintf(buf, "Socket error on socket = %d!", WSAGetLastError());
MessageBox(NULL, buf, NULL, MB_OK | MB_ICONEXCLAMATION);
if (con->pScreen != NULL)
DestroyWindow(con->pScreen->hWnd);
free(con);
free(tmpConfig);
return(-1);
}
con->socket = ret;
sockaddr.sin_family = AF_INET;
sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
sockaddr.sin_port = htons(0);
ret = bind(con->socket, (struct sockaddr *) &sockaddr,
(int) sizeof(struct sockaddr_in));
if (ret == SOCKET_ERROR) {
wsprintf(buf, "Socket error on bind!");
MessageBox(NULL, buf, NULL, MB_OK | MB_ICONEXCLAMATION);
if (con->pScreen != NULL)
DestroyWindow(con->pScreen->hWnd);
free(con);
free(tmpConfig);
return(-1);
}
WSAAsyncSelect(con->socket, hWnd, WM_NETWORKEVENT,
FD_READ | FD_CLOSE | FD_CONNECT);
lstrcpy(szHostName, tmpConfig->title);
p = strchr(szHostName, '@');
if (p != NULL) {
*p = 0;
strcpy (szUserName, szHostName);
strcpy(szHostName, ++p);
}
WSAAsyncGetHostByName(hWnd, WM_HOSTNAMEFOUND, szHostName, hostdata,
MAXGETHOSTSTRUCT);
ctl.encrypt = auth_encrypt;
ctl.decrypt = auth_decrypt;
ctl.init = auth_init;
ctl.destroy = auth_destroy;
con->ks = kstream_create_from_fd(con->socket, &ctl, NULL);
if (con->ks == NULL)
return(-1);
kstream_set_buffer_mode(con->ks, 0);
return(1);
}
int WAsyncSocket::Connect(char *host,unsigned short int port)
{
m_port=port;
WSAAsyncGetHostByName(m_hwnd,WM_GOT_HOST_BY_NAME_MESSAGE,host,m_hostent_buf,sizeof(m_hostent_buf));
return 0;
}
// ウィンドウメッセージを処理してデータを受信する
// 受信データは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;
}
void NetworkStream_Win32::Open( const RString &sHost, int iPort, ConnectionType ct )
{
m_Mutex.Lock();
if( m_State == STATE_CANCELLED )
{
m_Mutex.Unlock();
return;
}
// Always shut down a stream completely before reusing it.
ASSERT_M( m_State == STATE_IDLE, ssprintf("%s:%i: %i", sHost.c_str(), iPort, m_State) );
m_sHost = sHost;
m_iPort = iPort;
// Look up the hostname.
hostent *pHost = NULL;
char pBuf[MAXGETHOSTSTRUCT];
{
pHost = (hostent *) pBuf;
ResolveMessageWindow mw;
m_hResolve = WSAAsyncGetHostByName(
mw.GetHwnd(),
WM_USER,
m_sHost,
(char *) pHost,
MAXGETHOSTSTRUCT
);
m_hResolveHwnd = mw.GetHwnd();
m_Mutex.Unlock();
mw.Run();
m_Mutex.Lock();
m_hResolve = NULL;
m_hResolveHwnd = NULL;
if( m_State == STATE_CANCELLED )
{
m_Mutex.Unlock();
return;
}
int iError = mw.GetResult();
if( iError )
{
SetError( ssprintf("DNS error: %s", WinSockErrorToString(iError).c_str() ) );
m_Mutex.Unlock();
return;
}
m_Mutex.Unlock();
}
{
sockaddr_in addr;
addr.sin_addr.s_addr = *(DWORD *)pHost->h_addr_list[0];
addr.sin_family = PF_INET;
addr.sin_port = htons( (uint16_t) iPort );
m_Mutex.Lock();
m_Socket = socket( PF_INET, SOCK_STREAM, IPPROTO_TCP );
if( m_Socket == INVALID_SOCKET )
{
int iError = WSAGetLastError();
SetError( ssprintf("Error creating socket: %s", WinSockErrorToString(iError).c_str() ) );
return;
}
/* Set up the completion event to be signalled when these events occur.
* This also sets the socket to nonblocking. */
WSAEventSelect( m_Socket, m_hCompletionEvent, FD_CONNECT|FD_READ|FD_WRITE|FD_CLOSE );
//fcntl( m_Socket, O_NONBLOCK, 1 );
// Start opening the connection.
int iResult = connect(m_Socket, (SOCKADDR *) &addr, sizeof(addr));
m_Mutex.Unlock();
// We expect EINPROGRESS/WSAEWOULDBLOCK.
if( iResult == SOCKET_ERROR )
{
// Block until the connection attempt completes.
int iError = WSAGetLastError();
if( iError == WSAEWOULDBLOCK )
iError = WaitForCompletionOrCancellation( FD_CONNECT_BIT );
if( iError )
{
SetError( ssprintf("Couldn't connect: %s", WinSockErrorToString(iError).c_str() ) );
return;
}
}
}
m_State = STATE_CONNECTED;
}
*/ DEVICE_CMD Lookup_Socket(REBREQ *sock)
/*
** Initiate the GetHost request and return immediately.
** This is very similar to the DNS device.
** The request will pend until the main event handler gets WM_DNS.
** Note the temporary results buffer (must be freed later).
** Note we use the sock->handle for the DNS handle. During use,
** we store the TCP socket in the length field.
**
***********************************************************************/
{
#ifdef TO_WIN32
HANDLE handle;
#endif
HOSTENT *host;
#ifdef HAS_ASYNC_DNS
// Check if we are polling for completion:
if (host = (HOSTENT*)(sock->net.host_info)) {
// The windows main event handler will change this when it gets WM_DNS event:
if (!GET_FLAG(sock->flags, RRF_DONE)) return DR_PEND; // still waiting
CLR_FLAG(sock->flags, RRF_DONE);
if (!sock->error) { // Success!
host = (HOSTENT*)sock->net.host_info;
COPY_MEM((char*)&(sock->net.remote_ip), (char *)(*host->h_addr_list), 4); //he->h_length);
Signal_Device(sock, EVT_LOOKUP);
}
else
Signal_Device(sock, EVT_ERROR);
OS_Free(host); // free what we allocated earlier
sock->socket = sock->length; // Restore TCP socket saved below
sock->net.host_info = 0;
return DR_DONE;
}
// Else, make the lookup request:
host = OS_Make(MAXGETHOSTSTRUCT); // be sure to free it
handle = WSAAsyncGetHostByName(Event_Handle, WM_DNS, sock->data, (char*)host, MAXGETHOSTSTRUCT);
if (handle != 0) {
sock->net.host_info = host;
sock->length = sock->socket; // save TCP socket temporarily
sock->handle = handle;
return DR_PEND; // keep it on pending list
}
OS_Free(host);
#else
// Use old-style blocking DNS (mainly for testing purposes):
host = gethostbyname(sock->data);
sock->net.host_info = 0; // no allocated data
if (host) {
COPY_MEM((char*)&(sock->net.remote_ip), (char *)(*host->h_addr_list), 4); //he->h_length);
CLR_FLAG(sock->flags, RRF_DONE);
Signal_Device(sock, EVT_LOOKUP);
return DR_DONE;
}
#endif
sock->error = GET_ERROR;
//Signal_Device(sock, EVT_ERROR);
return DR_ERROR; // Remove it from pending list
}
