コード例 #1
0
ファイル: SharedSocket.cpp プロジェクト: BwRy/DarunGrim
LRESULT CALLBACK SharedSocketDataReceiverWndProc(HWND wnd,UINT message,WPARAM wp,LPARAM lp)
{
	switch (message)
	{
		case WM_SHARED_SOCKET_EVENT:
			{
				switch (WSAGETSELECTEVENT(lp))
				{
					case FD_READ:
						{
							SOCKET data_socket=(SOCKET)wp;
							char type;
							DWORD length;
						
							PBYTE data=RecvTLVData(data_socket,&type,&length);
							if(data)
							{
								gSharedSocketDataReceiver(data_socket,type,length,data);
							}else{
								//msg("Got Error on Socket\n");
							}
						
							//WSAAsyncSelect: READ|CLOSE
							if (WSAAsyncSelect(data_socket ,
								wnd,
								WM_SHARED_SOCKET_EVENT,
								FD_READ|FD_CLOSE
							) == SOCKET_ERROR)
							{
								/*
								print_function("failed to async select client %d, %X data_socket=%d, message_window=%X\n", 
									data_socket,
									WSAGetLastError(),
									data_socket,
									message_window);
								*/
							}							
						}
						break;
					case FD_CLOSE:
						closesocket((SOCKET)wp);
						break;
				}
			}
			break;
		default:
			return DefWindowProc(wnd, message, wp, lp);
	}
	return 0;
}
コード例 #2
0
void QEventDispatcherWin32Private::doWsaAsyncSelect(int socket)
{
    Q_ASSERT(internalHwnd);
    int sn_event = 0;
    if (sn_read.contains(socket))
        sn_event |= FD_READ | FD_CLOSE | FD_ACCEPT;
    if (sn_write.contains(socket))
        sn_event |= FD_WRITE | FD_CONNECT;
    if (sn_except.contains(socket))
        sn_event |= FD_OOB;
    // BoundsChecker may emit a warning for WSAAsyncSelect when sn_event == 0
    // This is a BoundsChecker bug and not a Qt bug
    WSAAsyncSelect(socket, internalHwnd, sn_event ? WM_QT_SOCKETNOTIFIER : 0, sn_event);
}
コード例 #3
0
/////////////////////////////////////////////////////////////////////////////////////////
// cleanup()
//
// cancel all notifications, close the socket and destroy the hook notification window.
//
// arguments: none.
// returns:   none.
//
void IDAconnector::cleanup (void)
{
    // cancel all notifications. if we don't do this ida will crash on exit.
    WSAAsyncSelect(connection, socket_hwnd, 0, 0);

    if (connected)
    {
        closesocket(connection);
        WSACleanup();
        DestroyWindow(socket_hwnd);
    }

    connected = false;
}
コード例 #4
0
ファイル: Server.cpp プロジェクト: Flying-Mosquito/Report
int Server::socketinit()
{
	for (int i = 0; i < 10; ++i)
	{
		for (int j = 0; j < 10; ++j)
		{
			ViewList[i][j].x = (800 / 10)*j;
			ViewList[i][j].y = (600 / 10)*i;
		}
	}

	WSADATA wsa;
	int ret = 0;

	if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
		cout << "winsock init error" << endl;

	sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, 0);

	SOCKADDR_IN addr;

	ZeroMemory(&addr, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	addr.sin_port = htons(9000);

	ret = WSAConnect(sock, (SOCKADDR*)&addr, sizeof(addr), NULL, NULL, NULL, NULL);

	WSAAsyncSelect(sock, Socket_HWND, WM_SOCKET, FD_READ | FD_CLOSE);

	WSA_send_buf.buf = Send_buf;
	WSA_send_buf.len = MAX_SIZE;
	WSA_recv_buf.buf = Recv_buf;
	WSA_recv_buf.len = MAX_SIZE;

	DWORD iobyte;

	cs_packet_accept *login =
		reinterpret_cast<cs_packet_accept*>(Send_buf);
	login->size = sizeof(cs_packet_accept);
	login->type = CS_LOGIN;

	ret = WSASend(sock, &WSA_send_buf, 1, &iobyte, 0, NULL, NULL);
	//cout << iobyte << endl;
	if (ret == SOCKET_ERROR)
		cout << "WSASend Error" << endl;

	return 1;
}
コード例 #5
0
ファイル: datagram.c プロジェクト: jiangxilong/yari
/**
 * Opens a datagram socket
 *
 * @param port The local port to attach to
 * @param pHandle address of variable to receive the handle; this is set
 *        only when this function returns JAVACALL_OK.
 *
 * @return JAVACALL_OK if the function completes successfully
 *         JAVACALL_FAIL if there was an IO error and IOException needs to be thrown;
 */
javacall_result javacall_datagram_open(
    int port,
  javacall_handle *pHandle) {

    SOCKET s;
    int truebuf = -1;
    int status;
    struct sockaddr_in addr;
    unsigned long nonblockingFlag = 1;

    s = socket(AF_INET, SOCK_DGRAM, 0);
    lastError = WSAGetLastError();
    if (INVALID_SOCKET == s) {
        return JAVACALL_OK;
    }

    status = setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
                        (char*)&truebuf, sizeof (truebuf));
    lastError = WSAGetLastError();
    if (SOCKET_ERROR == status) {
        (void)closesocket(s);
        return JAVACALL_FAIL;
    }

    addr.sin_family      = AF_INET;
    addr.sin_port        = htons((unsigned short)port);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    status = bind(s, (struct sockaddr*)&addr, sizeof (addr));
    lastError = WSAGetLastError();
    if (SOCKET_ERROR == status) {
        (void)closesocket(s);
        return JAVACALL_FAIL;
    }

    /* Set the socket to non-blocking. */
    ioctlsocket(s, FIONBIO, &nonblockingFlag);
     /*
       * Win32 only has one notifier per socket so always set both and
       * close, the MIDP event code can handle any extra notifications.
       * Do not cancel the notifications until the socket is closed.
       */
        WSAAsyncSelect(s, midpGetWindowHandle(), WM_NETWORK,
                           FD_READ | FD_WRITE | FD_CLOSE);

    *pHandle = (void*)s;

    return JAVACALL_OK;
  }
コード例 #6
0
BOOL Server(void) {
	DWORD		Ret;
	SOCKET		ListenSocket;
	struct		sockaddr_in InetAddr;
	WSADATA		wsaData;
	LPSTR		psBuff;

	WORD wVersionRequested = MAKEWORD(2,2);

	psBuff = (LPSTR)VirtualAlloc((LPVOID)NULL, (DWORD)(255),
					MEM_COMMIT, PAGE_READWRITE);

	if ((Ret = WSAStartup(wVersionRequested, &wsaData)) != 0) {
		wsprintf(psBuff, (LPCTSTR)"WSAStartup failed with error %d", Ret);
		AppendLog(psBuff);
		return FALSE;
	}

	if ((ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) 	{
		wsprintf(psBuff, (LPCTSTR)"socket() failed with error %d", WSAGetLastError());
		AppendLog(psBuff);
		return FALSE;
	}

	WSAAsyncSelect(ListenSocket, ghWndMain, WM_SOCKET, FD_ACCEPT | FD_CLOSE);

	wsprintf(psBuff, (LPCTSTR)"WM_SOCKET = %d", WM_SOCKET);
	AppendLog(psBuff);

	memset((char *)&InetAddr, 0, sizeof(struct sockaddr_in));
	InetAddr.sin_family = AF_INET;
	InetAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	InetAddr.sin_port = htons(PORT);

	if (bind(ListenSocket, (struct sockaddr *)&InetAddr, sizeof(InetAddr)) == SOCKET_ERROR) {
		wsprintf(psBuff, (LPCTSTR)"bind() failed with error %d", WSAGetLastError());
		AppendLog(psBuff);
		return FALSE;
	}

	if (listen(ListenSocket, 5)) {
		wsprintf(psBuff, (LPCTSTR)"listen() failed with error %d", WSAGetLastError());
		AppendLog(psBuff);
		return FALSE;
	}
	else {
		return TRUE;
	}
}
コード例 #7
0
ファイル: pcsl_udp.c プロジェクト: Sektor/phoneme-qtopia
/**
 * Common implementation between pcsl_datagram_read_start() 
 * and pcsl_datagram_read_finish().
 */
static int pcsl_datagram_read_common(void *handle, unsigned char *pAddress,
        int *port, char *buffer, int length, int *pBytesRead) {
    SOCKET s = (SOCKET)handle;
    struct sockaddr_in addr;
    int len = sizeof(struct sockaddr_in);
    int status;

    status = recvfrom(s, buffer, length, 0, (struct sockaddr*)&addr,  &len);
    lastError = WSAGetLastError();

    if (SOCKET_ERROR == status) {
        if (WSAEWOULDBLOCK == lastError) {
            /*
             * Win32 only has one notifier per socket so always set both and
             * close, the MIDP event code can handle any extra notifications.
             * Do not cancel the notifications until the socket is closed.
             */
            WSAAsyncSelect(s, win32app_get_window_handle(), WM_NETWORK,
                           FD_READ | FD_WRITE | FD_CLOSE);
            return PCSL_NET_WOULDBLOCK;
        }

        if (WSAECONNRESET == lastError) {
            /* The last call to sendto failed. Just return 0. */
            memset(pAddress, 0, sizeof(addr.sin_addr.s_addr)); 
            *port = 0;
            *pBytesRead = 0;

            return PCSL_NET_SUCCESS;
        }

        if (WSAEINTR == lastError) {
            return PCSL_NET_INTERRUPTED;
        }

        if (WSAEMSGSIZE == lastError) {
            /* The message was bigger than the buffer provided. */
            status = length;
        } else {
            return PCSL_NET_IOERROR;
        }
    }

    memcpy(pAddress, &addr.sin_addr.s_addr, sizeof(addr.sin_addr.s_addr)); 
    *port = ntohs(addr.sin_port);
    *pBytesRead = status;

    return PCSL_NET_SUCCESS;
}
コード例 #8
0
ファイル: Socket.cpp プロジェクト: dxzl/hydrairc
int Socket::ActualConnect( void ) // TODO: add "events" param
{
    m_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (m_sock == INVALID_SOCKET)
    {
        return SOCK_ERR_INVALID_SOCKET;
    }

    WSAAsyncSelect(m_sock, m_hWnd, m_MessageID, FD_CLOSE | FD_READ | FD_CONNECT | FD_ACCEPT);

    connect(m_sock, (struct sockaddr *)&m_sin, sizeof(m_sin));
    int result = WSAGetLastError(); // clear the WSAWOULDBLOCK error

    return SOCK_ERR_NONE;
}
コード例 #9
0
ファイル: ZeroconfBrowserMDNS.cpp プロジェクト: Anankin/xbmc
CZeroconfBrowserMDNS::~CZeroconfBrowserMDNS()
{
  CSingleLock lock(m_data_guard);
  //make sure there are no browsers anymore
  for(tBrowserMap::iterator it = m_service_browsers.begin(); it != m_service_browsers.end(); ++it )
    doRemoveServiceType(it->first);

#if defined(TARGET_WINDOWS)
  WSAAsyncSelect( (SOCKET) DNSServiceRefSockFD( m_browser ), g_hWnd, BONJOUR_BROWSER_EVENT, 0 );
#endif //TARGET_WINDOWS

  if (m_browser)
    DNSServiceRefDeallocate(m_browser);
  m_browser = NULL;
}
コード例 #10
0
ファイル: HTEvtLst.c プロジェクト: ChatanW/WebDaM
/*
**  For a given socket, reqister a request structure, a set of operations, 
**  a HTEventCallback function, and a priority. For this implementation, 
**  we allow only a single HTEventCallback function for all operations.
**  and the priority field is ignored.
*/
PUBLIC int HTEventList_register (SOCKET s, HTEventType type, HTEvent * event)
{
    int newset = 0;
    SockEvents * sockp;
    HTTRACE(THD_TRACE, "Event....... Register socket %d, request %p handler %p type %s at priority %d\n" _ 
		s _ (void *) event->request _ 
		(void *) event->cbf _ HTEvent_type2str(type) _ 
		(unsigned) event->priority);
    if (s==INVSOC || HTEvent_INDEX(type) >= HTEvent_TYPES)
	return 0;

    /*
    ** Insert socket into appropriate file descriptor set. We also make sure
    ** that it is registered in the global set.
    */
    HTTRACE(THD_TRACE, "Event....... Registering socket for %s\n" _ HTEvent_type2str(type));
    sockp = SockEvents_get(s, SockEvents_mayCreate);
    sockp->s = s;
    sockp->events[HTEvent_INDEX(type)] = event;
    newset = EventList_remaining(sockp);
#ifdef WWW_WIN_ASYNC
    if (WSAAsyncSelect(s, HTSocketWin, HTwinMsg, HTEvent_BITS(newset)) < 0) {
        HTTRACE(THD_TRACE, "Event....... WSAAsyncSelect returned `%s'!" _ HTErrnoString(socerrno));
	return HT_ERROR;
    }
#else /* WWW_WIN_ASYNC */
    FD_SET(s, FdArray+HTEvent_INDEX(type));

    HTTRACEDATA((char *) FdArray+HTEvent_INDEX(type), 8, "HTEventList_register: (s:%d)" _ s);

    if (s > MaxSock) {
	MaxSock = s ;
	HTTRACE(THD_TRACE, "Event....... New value for MaxSock is %d\n" _ MaxSock);
    }
#endif /* !WWW_WIN_ASYNC */

    /*
    **  If the timeout has been set (relative in millis) then we register 
    **  a new timeout for this event unless we already have a timer.
    */
    if (event->millis >= 0) {
	sockp->timeouts[HTEvent_INDEX(type)] =
	    HTTimer_new(sockp->timeouts[HTEvent_INDEX(type)],
			EventListTimerHandler, sockp, event->millis, YES, YES);
    }

    return HT_OK;
}
コード例 #11
0
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//函数:处理文件下载请求
//功能:收到文件下载请求,检验文件名合法性,会送合法文件名,文件大小
//输入:
//输出:
short CPRJ3_0613Dlg::StartSendFile(SOCKET s, int i)
{
	int buf_len;
	long retval;
	char *send_buf;
	FILE *fp;
	FilePDU file_pdu;

	fopen_s(&fp, FilePath[i], "rb");
	if (fp == NULL){
		//显示错误信息
		CString show_info;
		show_info += FilePath[i];
		show_info += "不存在!";
		//ShowInfo(show_info);

		///////////////////////////////////////////////告知用户发生错误
		//SendCtlPDU(s, RE_ERR_FILENAME);
		closesocket(s);///////////////////////////////////关闭套接字!还有后续!!!
		return -1;
	}

	//发送首帧
	file_pdu.type = FILE_PDU_TYPE;
	file_pdu.No = 0;
	retval = fread(file_pdu.buf, 1, FILE_BUF_SIZE, fp);
	file_pdu.len = retval;
	buf_len = 1 + 1 + 1 + retval;

	//send_buf = (char*)&file_pdu;
	retval = send(s, (char*)&file_pdu, buf_len, 0);
	if (retval <= 0){
		//返回值判定
		MessageBox(TEXT("数据连接发送数据PDU!"), TEXT("数据连接错误"), MB_OK);
		return retval;
	}

	sock_status[i] = S_SENDFILE_0;
	file_pointer[i] = fp;
	last_len[i] = retval - 3;

	SetTimer(i + 1, TIMEOUT, 0);

	WSAAsyncSelect(s, m_hWnd, WM_SEND_FILE_SOCK, FD_READ | FD_CLOSE);

	//free(file_pdu);
	return i;
}
コード例 #12
0
ファイル: ACWinSock.cpp プロジェクト: dgadens/ActionEngine
/**
 * Create socketobjects as server and make them ready for traffic.
 * The server just needs to listen to the port the client is sending
 * its data to.
 */
HRESULT ACWinSock::CreateServer(ACSocketObject **ppSkObject) 
{
   UINT nEvents=0;

	//Log("firing up server");
	(*ppSkObject) = new ACSocketObject(mpLOG);
   
	if (!(*ppSkObject)) 
	{
		Log("[ERROR]  m_pSkObject construction failed in ACWinSock::CreateServer");
		return AC_FAIL;
	}
	Log("ACSocketObjects constructed");

	// 1. step: create a socket object
	if (FAILED( (*ppSkObject)->CreateSocket() ))
		return AC_FAIL;
	Log("socket created");
   
	// 2. step: name the socket cause it's a server
	if (FAILED( (*ppSkObject)->Bind(mPort) ))
		return AC_FAIL;
	Log("server bind to port: %d", mPort);

	// 3. step: listen for incoming connection requests
	if (FAILED( (*ppSkObject)->Listen() ))
		return AC_FAIL;
	Log("server is now listening for incoming connection...");

	nEvents |= FD_READ | FD_WRITE | FD_CONNECT | FD_ACCEPT | FD_CLOSE;

	// 4. step: notification from windows WM_ about incoming events
	if (WSAAsyncSelect((*ppSkObject)->GetSocket(), mActiveWnd, WM_ACSERVER, nEvents)==SOCKET_ERROR) 
	{
		Log("[ERROR]  WSAAsyncSelect(WM_ACSERVER) failed");
		mpSockObj->Disconnect();
		return AC_FAIL;
	}

	// initialize all client slots as invalid
	for (int i=0; i<256; i++) 
	{
		mClients[i].skToClient = INVALID_SOCKET;
		mClients[i].nID = 0;
	}

	return AC_OK;
};
コード例 #13
0
/*
    This function is the entry point for the AsyncSelect Accept implementation.
*/
void AsyncSelectAcceptMain()
{
    PSOCK_INFO pSockInfo;
    int rc;
    MSG msg;
     
    printf("Entering AsyncSelectAcceptMain()\n");

    // create a dummy hidden window to receive the async select messages.
    g_AcceptContext.hAcceptWindow = CreateAcceptWindow();
    if (g_AcceptContext.hAcceptWindow == NULL)
    {
        printf("Error in creating the accept window.\n");
        goto CLEANUP;
    }

    // Set for all the listening sockets to be signalled on FD_ACCEPT event.
    for(pSockInfo = g_AcceptContext.pSockList; pSockInfo != NULL;
                                               pSockInfo = pSockInfo->next)
    {
        // request asynchronous notifications for the FD_ACCEPT and FD_CLOSE
        // events to be sent to the hAcceptWindow for this sock.
        rc = WSAAsyncSelect(pSockInfo->sock,
                            g_AcceptContext.hAcceptWindow, 
                            WM_USER_ASYNCSELECT_MSG,
                            FD_ACCEPT | FD_CLOSE);
        if (rc == SOCKET_ERROR)
        {
            printf("ERROR: WSAAsyncSelect failed for sock %d. Error = %d\n", 
                                    pSockInfo->sock, WSAGetLastError());
            continue;                                                  
        }
    }

    // Main message loop to process messages to the Accept Window.
    // This will indirectly call MainWndProc which will in turn call
    // ProcessAsyncSelectMessage.
    while (GetMessage(&msg, (HWND) NULL, 0, 0)) { 
        TranslateMessage(&msg); 
        DispatchMessage(&msg); 
    } 

   
CLEANUP:        

    printf("Exiting AsyncSelectAcceptMain()\n");
    return ;
}
コード例 #14
0
ファイル: ZeroconfBrowserMDNS.cpp プロジェクト: intrcomp/xbmc
bool CZeroconfBrowserMDNS::doAddServiceType(const std::string& fcr_service_type)
{
  DNSServiceErrorType err;
  DNSServiceRef browser = NULL;

#if !defined(HAS_MDNS_EMBEDDED)
  if(m_browser == NULL)
  {
    err = DNSServiceCreateConnection(&m_browser);
    if (err != kDNSServiceErr_NoError)
    {
      CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: DNSServiceCreateConnection failed with error = %ld", (int) err);
      return false;
    }
#if defined(TARGET_WINDOWS_DESKTOP)
    err = WSAAsyncSelect( (SOCKET) DNSServiceRefSockFD( m_browser ), g_hWnd, BONJOUR_BROWSER_EVENT, FD_READ | FD_CLOSE );
    if (err != kDNSServiceErr_NoError)
      CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: WSAAsyncSelect failed with error = %ld", (int) err);
#elif defined(TARGET_WINDOWS_STORE)
    // need to modify this code to use WSAEventSelect since WSAAsyncSelect is not supported
    CLog::Log(LOGERROR, "%s is not implemented for TARGET_WINDOWS_STORE", __FUNCTION__);
#endif // TARGET_WINDOWS_STORE
  }
#endif //!HAS_MDNS_EMBEDDED

  {
    CSingleLock lock(m_data_guard);
    browser = m_browser;
    err = DNSServiceBrowse(&browser, kDNSServiceFlagsShareConnection, kDNSServiceInterfaceIndexAny, fcr_service_type.c_str(), NULL, BrowserCallback, this);
  }

  if( err != kDNSServiceErr_NoError )
  {
    if (browser)
      DNSServiceRefDeallocate(browser);

    CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: DNSServiceBrowse returned (error = %ld)", (int) err);
    return false;
  }

  //store the browser
  {
    CSingleLock lock(m_data_guard);
    m_service_browsers.insert(std::make_pair(fcr_service_type, browser));
  }

  return true;
}
コード例 #15
0
ファイル: wsGameServer.cpp プロジェクト: 331515194/zTeamS6.3
BOOL CwsGameServer::CreateServer(LPSTR ip_addr, WORD port, DWORD WinServerMsg, DWORD WinClientMsg)
{
	sockaddr_in addr;
	int nResult;
	
	if (this->m_hWnd == 0 )
	{
		MsgBox("windows handle error");
		return 0;
	}

	memset(&addr, 0, sizeof(addr) );

	addr.sin_family=AF_INET; // INET
	addr.sin_addr.S_un.S_addr=htonl(0);
	addr.sin_port=htons(port);

	nResult=bind(this->m_socket, (sockaddr*)&addr, 16);

	if ( nResult == -1 )
	{
		LogAdd("Server bind error %d", WSAGetLastError() );
		closesocket(this->m_socket);
		return 0;
	}

	nResult=listen(this->m_socket , 4);

	if (nResult == -1)
	{
		closesocket(this->m_socket );
		LogAdd("Server listen error %d", WSAGetLastError() );
		return 0;
	}

	nResult=WSAAsyncSelect( this->m_socket , this->m_hWnd , WinServerMsg, FD_ACCEPT);

	if (nResult == -1)
	{
		closesocket(this->m_socket);
		LogAdd("Server WSAAsyncSelect error %d", WSAGetLastError());
		return 0;
	}

	this->m_WinClientMsg  =WinClientMsg;
	return 1;
}
コード例 #16
0
ファイル: sntp.c プロジェクト: h16o2u9u/rtoss
/*---------------------------------------------------
	send SNTP data
---------------------------------------------------*/
void SNTPSend(HWND hwnd, unsigned long serveraddr)
{
	struct sockaddr_in serversockaddr;
	struct NTP_Packet NTP_Send;
	unsigned int sntpver;
	unsigned int Control_Word;

	// request notification of events
	if(WSAAsyncSelect(g_socket, hwnd, WSOCK_SELECT, FD_READ) == SOCKET_ERROR)
	{
		SocketClose(hwnd, "WSAAsyncSelect() failed");
		return;
	}

	// set IP address and port
	serversockaddr.sin_family = AF_INET;
	serversockaddr.sin_addr.s_addr = serveraddr;
	serversockaddr.sin_port = htons((unsigned short)g_port);
	memset(serversockaddr.sin_zero,(int)0,sizeof(serversockaddr.sin_zero));


	// init a packet
	memset(&NTP_Send, 0, sizeof(struct NTP_Packet));
	// NTP/SNTP version number = 4
	// Mode = 3 (client)
	// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
	// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	// |LI | VN  |Mode |    Stratum    |     Poll      |   Precision   |
	// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	sntpver = GetMyRegLong("SNTP", "SNTPVer", 4);
	Control_Word = (sntpver << 27) | (3 << 24);
	NTP_Send.Control_Word = htonl(Control_Word);

	// send a packet
	if(sendto(g_socket, (const char *)&NTP_Send, sizeof(NTP_Send), 0,
		(struct sockaddr *)&serversockaddr,
		sizeof(serversockaddr)) == SOCKET_ERROR)
	{
		SocketClose(hwnd, "sendto() failed");
		return;
	}


	// save tickcount
	dwTickCountOnSend = GetTickCount();
	bSendingData = TRUE;
}
コード例 #17
0
ファイル: SICK.cpp プロジェクト: sunacc/Basketball_Robot
int SICK::SICKConnect()
{
	// Declare and initialize variables 	
	WSADATA wsaData;	
	int iResult;	
	//----------------------
	// Initialize Winsock
	iResult = WSAStartup(MAKEWORD(2,1), &wsaData);
	if (iResult != NO_ERROR) {
		m_SickConnectionInfo.m_SICKConnectErrorCode=1;		 //SOCKET初始化错误
		return m_SickConnectionInfo.m_SICKConnectErrorCode ;
	}	
	//----------------------
	// Create a SOCKET for connecting to server
	m_SickConnectionInfo.m_SICKSOCKET = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (m_SickConnectionInfo.m_SICKSOCKET  == INVALID_SOCKET) {
		WSACleanup();
		m_SickConnectionInfo.m_SICKConnectErrorCode=2;		//无法创建客户端SOCKET
		return m_SickConnectionInfo.m_SICKConnectErrorCode ;
	}			
	//----------------------
	// The sockaddr_in structure specifies the address family,
	// IP address, and port of the server to be connected to.
	m_SickConnectionInfo.clientService.sin_family = AF_INET;
	CString strSICKIP;
	IN_ADDR ia; 	
	ia.S_un.S_addr=htonl(m_SickSetting.m_SICKIP); 
	strSICKIP=inet_ntoa(ia);
	m_SickConnectionInfo.clientService.sin_addr.s_addr = inet_addr(strSICKIP);
	m_SickConnectionInfo.clientService.sin_port = htons(unsigned short(m_SickSetting.m_SICKPort));	
	//----------------------
	// Connect to server.	
	iResult = connect(m_SickConnectionInfo.m_SICKSOCKET, 
		(SOCKADDR*) &m_SickConnectionInfo.clientService, sizeof(m_SickConnectionInfo.clientService) );
	if ( iResult == SOCKET_ERROR) {
		closesocket (m_SickConnectionInfo.m_SICKSOCKET);
		WSACleanup();
		m_SickConnectionInfo.m_SICKConnectErrorCode=3;		//无法连接服务器
		Invalidate();
		return m_SickConnectionInfo.m_SICKConnectErrorCode ;
	}
	WSAAsyncSelect(m_SickConnectionInfo.m_SICKSOCKET,m_hWnd,WM_SICKSOCKET_READ_CLOSE,FD_READ|FD_CLOSE);
	// 产生相应传递给窗口的消息为WM_LASER_CLIENT_READ_CLOSE ,这是自定义消息	
	//set Laser .	
	m_SickConnectionInfo.m_SICKConnectErrorCode=-1;
	return m_SickConnectionInfo.m_SICKConnectErrorCode;
}
コード例 #18
0
ファイル: AsyncSocketExLayer.cpp プロジェクト: mengskysama/V8
BOOL CAsyncSocketExLayer::CreateNext(UINT nSocketPort, int nSocketType, long lEvent, char* lpszSocketAddress)
{
	ASSERT(GetLayerState()==notsock);
	BOOL res=FALSE;
	if (m_pNextLayer)
		res=m_pNextLayer->Create(nSocketPort, nSocketType, lEvent, lpszSocketAddress);
	else
	{
		SOCKET hSocket=socket(AF_INET, nSocketType, 0);
		if (hSocket==INVALID_SOCKET)
			res=FALSE;

/*
		unsigned long ul = 1;
		ioctlsocket(hSocket, FIONBIO, (unsigned long*)&ul);
		
		int iTimerout = 6000;
		setsockopt( hSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&iTimerout, sizeof( iTimerout));
*/

		m_pOwnerSocket->m_SocketData.hSocket=hSocket;
		m_pOwnerSocket->AttachHandle(hSocket);
		if (!m_pOwnerSocket->AsyncSelect(lEvent))
		{
			m_pOwnerSocket->Close();
			res=FALSE;
		}
		if (m_pOwnerSocket->m_pFirstLayer)
		{
			if (WSAAsyncSelect(m_pOwnerSocket->m_SocketData.hSocket, m_pOwnerSocket->GetHelperWindowHandle(), m_pOwnerSocket->m_SocketData.nSocketIndex+WM_SOCKETEX_NOTIFY, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE) )
			{
				m_pOwnerSocket->Close();
				res=FALSE;
			}
		}
		if (!m_pOwnerSocket->Bind(nSocketPort, lpszSocketAddress))
		{
			m_pOwnerSocket->Close();
			res=FALSE;
		}
		res=TRUE;
	}
	if (res)
		SetLayerState(unconnected);
	return res;
}
コード例 #19
0
BOOL CListener::Start(HWND hWnd)
{
	if (!Initialize())
	{
		return FALSE;
	}

	if (WSAAsyncSelect(m_ListenSock, hWnd, WM_SOCKET, FD_ACCEPT|FD_READ|FD_CLOSE) == SOCKET_ERROR)
	{
		CleanUp();
		return FALSE;
	}

	// Start some others here

	return TRUE;
}
コード例 #20
0
ファイル: idanet.cpp プロジェクト: FlankerZ/collabREate
/////////////////////////////////////////////////////////////////////////////////////////
//cleanup(bool warn)
//
//cancel all notifications, close the socket and destroy the hook notification window.
//
//arguments: warn true displays a warning that cleanup is being called, false no warning
//returns:   none.
//
void cleanup(bool warn) {
   //cancel all notifications. if we don't do this ida will crash on exit.
   msg(PLUGIN_NAME": cleanup called.\n");
   if (conn != INVALID_SOCKET) {
      if (msg_hwnd) {
         WSAAsyncSelect(conn, msg_hwnd, 0, 0);
         dispatch = NULL;
      }
      closesocket(conn);
      conn = INVALID_SOCKET;
      if (warn) {
         warning("Connection to collabREate server has been closed.\n"
                 "You should reconnect to the server before sending\n"
                 "additional updates.");
      }
   }
}
コード例 #21
0
ファイル: Network.cpp プロジェクト: RabidSquabbit/ElDorito
		bool StartInfoServer()
		{
			if (infoSocketOpen)
				return true;

			Server::Voting::StartNewVote();
			HWND hwnd = Pointer::Base(0x159C014).Read<HWND>();
			if (hwnd == 0)
				return false;

			infoSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
			SOCKADDR_IN bindAddr;
			bindAddr.sin_family = AF_INET;
			bindAddr.sin_addr.s_addr = htonl(INADDR_ANY);

			unsigned long port = Modules::ModuleServer::Instance().VarServerPort->ValueInt;
			if (port == Pointer(0x1860454).Read<uint32_t>()) // make sure port isn't the same as game port
				port++;
			bindAddr.sin_port = htons((u_short)port);

			// open our listener socket
			while (bind(infoSocket, (PSOCKADDR)&bindAddr, sizeof(bindAddr)) != 0)
			{
				port++;
				if (port == Pointer(0x1860454).Read<uint32_t>()) // make sure port isn't the same as game port
					port++;
				bindAddr.sin_port = htons((u_short)port);
				if (port > (Modules::ModuleServer::Instance().VarServerPort->ValueInt + 10))
					return false; // tried 10 ports, lets give up
			}
			Modules::CommandMap::Instance().SetVariable(Modules::ModuleServer::Instance().VarServerPort, std::to_string(port), std::string());

			//Setup UPnP
			if (Modules::ModuleUPnP::Instance().VarUPnPEnabled->ValueInt)
			{
				Modules::ModuleUPnP::Instance().UPnPForwardPort(true, port, port, "ElDewrito InfoServer");
				Modules::ModuleUPnP::Instance().UPnPForwardPort(false, Pointer(0x1860454).Read<uint32_t>(), Pointer(0x1860454).Read<uint32_t>(), "ElDewrito Game");
				Modules::ModuleUPnP::Instance().UPnPForwardPort(false, 9987, 9987, "ElDewrito VoIP");
			}

			WSAAsyncSelect(infoSocket, hwnd, WM_INFOSERVER, FD_ACCEPT | FD_CLOSE);
			listen(infoSocket, 5);
			infoSocketOpen = true;

			return true;
		}
コード例 #22
0
ファイル: LBaseSock.cpp プロジェクト: japgo/mygithub
/*========================================================================================
	FUNCTION: LBaseSock::Accept()
	DESCRIPT: Accept the socket connection.
	RETURN	:
		EWS_NO_ERR: Success!
		Others	  : System error code
	ARGUMENT:
		Sock: (i)Socket descriptor
	UPDATE	: 2004/07/01, In-hyeok Paek; First work!
========================================================================================*/
int LBaseSock::Accept( SOCKET Sock )
{
	SOCKADDR_IN		SockAddr;	//	Socket information structure
	int		nLen;	//	Length of the block
	int		nResult;	//	Function result

	//	Accept the socket connection.
	nLen = sizeof( SOCKADDR );
	m_Sock = accept( Sock, (LPSOCKADDR)&SockAddr, &nLen );
	if( m_Sock == INVALID_SOCKET ) { return (m_nLastErr = WSAGetLastError()); }

	//	Select the socket event.
	nResult = WSAAsyncSelect( m_Sock, m_hWnd, WM_SOCK_SOCKET,
							  FD_CLOSE | FD_READ | FD_WRITE );
	if( nResult == SOCKET_ERROR ) { return (m_nLastErr = WSAGetLastError()); }

	return EWS_NO_ERR;
}
コード例 #23
0
ファイル: ZeroconfBrowserMDNS.cpp プロジェクト: intrcomp/xbmc
CZeroconfBrowserMDNS::~CZeroconfBrowserMDNS()
{
  CSingleLock lock(m_data_guard);
  //make sure there are no browsers anymore
  for(tBrowserMap::iterator it = m_service_browsers.begin(); it != m_service_browsers.end(); ++it )
    doRemoveServiceType(it->first);

#if defined(TARGET_WINDOWS_DESKTOP)
  WSAAsyncSelect( (SOCKET) DNSServiceRefSockFD( m_browser ), g_hWnd, BONJOUR_BROWSER_EVENT, 0 );
#elif  defined(TARGET_WINDOWS_STORE)
  // need to modify this code to use WSAEventSelect since WSAAsyncSelect is not supported
  CLog::Log(LOGDEBUG, "%s is not implemented for TARGET_WINDOWS_STORE", __FUNCTION__);
#endif //TARGET_WINDOWS

  if (m_browser)
    DNSServiceRefDeallocate(m_browser);
  m_browser = NULL;
}
コード例 #24
0
ファイル: Serverstuff.cpp プロジェクト: Stratege/TWIRC
void ServerCF::Accept()
{
	struct sockaddr_in client;

	int len;


	len = sizeof( client );

        ToClientSocket = accept(serverSocket, (struct sockaddr*)&client, &len);
	if(ToClientSocket < 0){
		//error handling
	}else{
		WSAAsyncSelect(serverSocket,g_pWindow,WM_TOCLIENTSOCKET,(FD_READ|FD_CLOSE));
		//we don't want more than one connection, cause it crashes
		closesocket(serverSocket);
	}
}
コード例 #25
0
ファイル: flyplus.cpp プロジェクト: jhp333/aux
int CreateInitSockClient(HWND hwnd, SOCKET& sock, sockaddr_in sa, char *buf)
{
	int i;
	char lineErr[256], buf2[128];
	CHECKERR(sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP), FL_ERR_SOCKET);
	CHECKERR(i = WSAAsyncSelect (sock, hwnd, WM_FLY_TASKS, FD_CONNECT | FD_WRITE | FD_READ | FD_CLOSE ), FL_ERR_WSAAYNC);
	i=connect (sock, (SOCKADDR *)&sa, sizeof(sa));
	if (i==-1)
	{
		if (WSAGetLastError()!=WSAEWOULDBLOCK)
		{
			sprintf(buf, "code=%d", i);
			MessageBox (NULL, buf, "Error in connect", MB_OK);
		}
	}
	_beginthreadex (NULL, 0, ConnectingThread, (void*)sock, 0, &connectThreadID);
	return i;
}
コード例 #26
0
ファイル: pal.c プロジェクト: mixtile/xskit
int xsSocketCreate(void)
{
	SOCKET sock;
	int ret;

	sock = socket(PF_INET, SOCK_STREAM, 0);
	if (sock == INVALID_SOCKET)
		return XS_EC_ERROR;

	ret = WSAAsyncSelect(sock, g_hMainWnd, WM_XS_SOCKET_MSG, FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE);
	if (ret != 0)
	{
		closesocket(sock);
		return XS_EC_ERROR;
	}

	return sock;
}
コード例 #27
0
ファイル: tftp_cli.c プロジェクト: luoxiaobing/tftp
///////////////////////////////////////////////////////
// End of transfer : 
///////////////////////////////////////////////////////
static void StopTransfer (void)
{
    // stop transfer
    WSAAsyncSelect (sTC.s, hTftpClientWnd, 0, 0);
    KillTimer(hTftpClientWnd, WM_CLIENT_DATA);
    KillTimer(hTftpClientWnd, WM_CLIENT_ACK);
    // free resource
    closesocket (sTC.s);      sTC.s = INVALID_SOCKET;
    CloseHandle (sTC.hFile);  sTC.hFile = INVALID_HANDLE_VALUE;
    sTC.bConnected = TFTP_NOTCONNECTED;
    // reinit buttons
    EnableWindow (GetDlgItem (GetParent(hTftpClientWnd), IDC_CLIENT_SEND_BUTTON), TRUE);
    EnableWindow (GetDlgItem (GetParent(hTftpClientWnd), IDC_CLIENT_GET_BUTTON), TRUE);
    EnableWindow (GetDlgItem (GetParent(hTftpClientWnd), IDC_CLIENT_BREAK_BUTTON), FALSE);
    SetDlgItemText (GetParent(hTftpClientWnd), IDC_CLIENT_BLOCK, "");
    SendDlgItemMessage (GetParent(hTftpClientWnd), IDC_CLIENT_PROGRESS, PBM_SETPOS, 0, 0);

} // StopTransfer
コード例 #28
0
ファイル: connection.cpp プロジェクト: kwolekr/horizon
bool ConnectAsyncSocket(int index, char *server, unsigned short port) {
	struct sockaddr_in sName;
	SOCKET sck;

	sck = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sck == INVALID_SOCKET)
		return false;

	if (WSAAsyncSelect(sck, bot[index]->hWnd_main, WM_WSDATAARRIVAL,
		FD_READ | FD_CLOSE | FD_CONNECT) == SOCKET_ERROR)
		return false;

	memset(&sName, 0, sizeof(sName));
	sName.sin_family = AF_INET;
	sName.sin_port   = htons(port);

	char *p = server;
	while (*p && (isdigit(*p) || (*p == '.')))
		p++;

	if (*p) {
		struct hostent *hstEnt = gethostbyname(server);
		if (!hstEnt) {
			closesocket(sck);
			return false;
		}
		memcpy(&sName.sin_addr, hstEnt->h_addr, hstEnt->h_length);
	} else {
		sName.sin_addr.s_addr = inet_addr(server);
	}

	if (connect(sck, (struct sockaddr *)&sName, sizeof(sName))) {
		int tmp = WSAGetLastError();
		if (tmp != WSAEWOULDBLOCK) {
			shutdown(sck, SD_BOTH);
			closesocket(sck);
			return false;
		}
	}

	bot[index]->sck = sck;

	return true;
}
コード例 #29
0
ファイル: LBaseSock.cpp プロジェクト: japgo/mygithub
/*========================================================================================
	FUNCTION: LBaseSock::Listen()
	DESCRIPT: Listen connections for the server socket.
	RETURN	:
		EWS_NO_ERR: Success!
		Others	  : System error code
	ARGUMENT:
		szAddr	   : (i)IP address
		nPort	   : (i)Port #
		nMaxConnect: (i)Max. # of connections accepted (Default = 1)
	UPDATE	: 2004/07/01, In-hyeok Paek; First work!
========================================================================================*/
int LBaseSock::Listen( char *szAddr, int nPort, int nMaxConnect )
{
	SOCKADDR_IN		SockAddr;	//	Socket address structure
	BOOL	bOpt = true;
	DWORD	dwResult;	//	Function result
	int		nResult;	//	Function result

	//	Get the socket descriptor.
	if( (m_Sock = socket( AF_INET, SOCK_STREAM, 0 )) == INVALID_SOCKET ) {
		return (m_nLastErr = WSAGetLastError());
	}

	//	Set the socket option.
	setsockopt( m_Sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&bOpt, sizeof( bOpt ) );

	//	Bind socket.
	SockAddr.sin_family = AF_INET;
	SockAddr.sin_port = htons( (u_short)nPort );
	if( szAddr == NULL ) { SockAddr.sin_addr.s_addr = htonl( INADDR_ANY ); }
	else {
		dwResult = inet_addr( szAddr );
		if( dwResult == INADDR_NONE ) { return (m_nLastErr = WSAGetLastError()); }
		SockAddr.sin_addr.s_addr = dwResult;
	}
	if( bind( m_Sock, (LPSOCKADDR)&SockAddr, sizeof( SOCKADDR ) ) == SOCKET_ERROR ) {
		return (m_nLastErr = WSAGetLastError());
	}

	//	Select the socket event.
	nResult = WSAAsyncSelect( m_Sock, m_hWnd, WM_SOCK_SOCKET,
							  FD_ACCEPT | FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE );
	if( nResult == SOCKET_ERROR ) { return (m_nLastErr = WSAGetLastError()); }

	//	Listen connections.
	if( listen( m_Sock, nMaxConnect ) == SOCKET_ERROR ) {
		m_nLastErr = WSAGetLastError();
		closesocket( m_Sock );
		m_Sock = INVALID_SOCKET;
		return m_nLastErr;
	}
	m_fListenSocket = true;

	return EWS_NO_ERR;
}
コード例 #30
0
//=============================================================================
BOOL XSocket::bConnect(char * pAddr, int iPort, unsigned int uiMsg)
{
 SOCKADDR_IN	 saTemp;
 u_long          arg;
 int             iRet;
 DWORD			 dwOpt;
 PutLogList("bConnect");
	if (m_cType == XSOCK_LISTENSOCK) return FALSE;
	if (m_Sock  != INVALID_SOCKET) closesocket(m_Sock);

	m_Sock = socket(AF_INET, SOCK_STREAM, 0);
	if (m_Sock == INVALID_SOCKET) 
		return FALSE;
	
	arg = 1;
	ioctlsocket(m_Sock, FIONBIO, &arg);
	
	memset(&saTemp,0,sizeof(saTemp));
	saTemp.sin_family = AF_INET;
	saTemp.sin_addr.s_addr = inet_addr(pAddr);
	saTemp.sin_port = htons(iPort);
	
	iRet = connect(m_Sock, (struct sockaddr *) &saTemp, sizeof(saTemp));
	if (iRet == SOCKET_ERROR) {
		if (WSAGetLastError() != WSAEWOULDBLOCK) {
			m_WSAErr = WSAGetLastError();
			return FALSE;
		}
	}

	WSAAsyncSelect(m_Sock, m_hWnd, uiMsg, FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE);
	dwOpt = 8192*5;
	setsockopt(m_Sock, SOL_SOCKET, SO_RCVBUF, (const char FAR *)&dwOpt, sizeof(dwOpt));
	setsockopt(m_Sock, SOL_SOCKET, SO_SNDBUF, (const char FAR *)&dwOpt, sizeof(dwOpt));


	SafeCopy(m_pAddr, pAddr);
	m_iPortNum = iPort;

	m_uiMsg = uiMsg;
	m_cType = XSOCK_NORMALSOCK;

	return TRUE;
}//=============================================================================