自学教程：C++ CreateSocket函数代码示例

int main(int argc, char **argv){	Preferences::Instance()->SetFile("/boot/home/config/settings/RemoteControl.perfs");		args.porti=4321;	args.ports=4322;	args.passwd=0;		parse(argc, argv);		MyApp *app=new MyApp();		int32 socki=CreateSocket(args.porti);	int32 socks=CreateSocket(args.ports);		if((socki<0) || (socks<0))		return 1;		new InputListener (socki, args.passwd);	new ScreenListener(socks, args.passwd);		app->Run();		return 0;}

void UdpSocket::CreateConnection(){#ifdef ENABLE_IPV6#ifdef IPPROTO_IPV6	if (IsIpv6())	{		if (GetSocket() == INVALID_SOCKET)		{			SOCKET s = CreateSocket(AF_INET6, SOCK_DGRAM, "udp");			if (s == INVALID_SOCKET)			{				return;			}			SetNonblocking(true, s);			Attach(s);		}		return;	}#endif#endif	if (GetSocket() == INVALID_SOCKET)	{		SOCKET s = CreateSocket(AF_INET, SOCK_DGRAM, "udp");		if (s == INVALID_SOCKET)		{			return;		}		SetNonblocking(true, s);		Attach(s);	}}

int EgSock::Connect(const char* ip, uint16_t port, function<void(sp_EgSock)> callback) {	_fd = CreateSocket();	SetNonblock(fd);	SetNodelay(fd);	_peer_ip = ip;	_port = port;	_state = EG_SOCK_CONNECTING;	_callback = callback;	sockaddr_in serv_addr;	SetAddr(ip, port,  &serv_addr);	if (connect(_fd, (sockaddr*)&serv_addr, sizeof(serv_addr)) == SOCKET_ERROR) {		if (!((errno == EINPROGRESS) || (errno == EWOULDBLOCK))) {			loge("connect failed, err_code=%d", errno);			close(_fd);			throw egex("connect failed, errno=%d", errno);		}	} else {		_state = EG_SOCK_CONNECTED;		callback(shared_from_this());	}	return _fd;}

int CLS_TCPSvr::Listen(){    char *strIP;    if(m_iStatus==SS_UNUSED)        if(CreateSocket()<0)            return -1;    if(m_iStatus!=SS_LISTEN)    {        if(m_iStatus!=SS_BOUND)            if(Bind()<0)                return -2;        if (listen(m_iSocket, 5)<0)         {            CloseSocket();            return -3;        }        if(!m_iLocalPort)        {            strIP=GetLocalHost(&m_iLocalPort);            if(strIP)                strcpy(m_strLocalIP, strIP);        }        m_iStatus=SS_LISTEN;    }    return 0;}

//  Write a socketwxInt32 BufferedSocket::SendData(const wxInt32 &Timeout){       wxInt32 BytesSent;        if (CreateSocket() == false)        return 0;    // clear it    memset(m_SendBuffer, 0, MAX_PAYLOAD);        // copy data    size_t WrittenSize = m_SendBufferHandler->CopyTo(m_SendBuffer,                                                       MAX_PAYLOAD);    // Creation of this will start the stop watch    wxStopWatch sw;                    // send the data    BytesSent = send(m_Socket, (const char *)m_SendBuffer, WrittenSize, 0);    // set the start ping    m_SendPing = sw.Time();        CheckError();                // return the amount of bytes sent    return BytesSent;}

nsresultKeyStoreConnector::CreateListenSocket(struct sockaddr* aAddress,                                      socklen_t* aAddressLength,                                      int& aListenFd){  ScopedClose fd;  nsresult rv = CreateSocket(fd.rwget());  if (NS_FAILED(rv)) {    return rv;  }  rv = SetSocketFlags(fd);  if (NS_FAILED(rv)) {    return rv;  }  if (aAddress && aAddressLength) {    rv = CreateAddress(*aAddress, *aAddressLength);    if (NS_FAILED(rv)) {      return rv;    }  }  // Allow access for wpa_supplicant (different user, different group)  //  // TODO: Improve this by setting specific user/group for  //       wpa_supplicant by calling |fchmod| and |fchown|.  //  chmod(KEYSTORE_SOCKET_PATH, S_IRUSR|S_IWUSR|                              S_IRGRP|S_IWGRP|                              S_IROTH|S_IWOTH);  aListenFd = fd.forget();  return NS_OK;}

int Client::Run(const char* pIP, unsigned short uPort, const char * pFileName){    int iRet = 0;    if (pIP == NULL)    {        iRet = -1;        return iRet;    }    memccpy(m_sIPAddress, pIP, 0, sizeof(m_sIPAddress) - 1);    m_sIPAddress[sizeof(m_sIPAddress) - 1] = 0;    m_uPort = uPort;    if (pFileName != NULL) {        m_RequireType = 2; //File        memccpy(m_sFilename, pFileName, 0, sizeof(m_sFilename) - 1);        m_sFilename[sizeof(m_sFilename) - 1] = 0;    }    else    {        m_RequireType = 1; //DIR    }    CreateSocket();    ConnectSocket();    return iRet;}

DWORD CEgTcpDriver::CreateAcceptSocket(BOOL bBindIocp){    DWORD       dwRecvNumBytes = 0;     	DWORD		dwRes;    if (bBindIocp)    {		m_ListenSocketContext.m_ConnectioID.m_Socket = m_ListenSocket;		m_ListenSocketContext.m_pIOContext.m_IoOperation = ClientIoAccept;        dwRes = BindCompletionPort(m_ListenSocketContext);        if (dwRes != 0)            return dwRes;    }    m_ListenSocketContext.m_pIOContext.m_SocketAccept = CreateSocket();    if (INVALID_SOCKET == m_ListenSocketContext.m_pIOContext.m_SocketAccept)        return WSAGetLastError();    int nRet = AcceptEx(            m_ListenSocket,             m_ListenSocketContext.m_pIOContext.m_SocketAccept,            (LPVOID)(m_ListenSocketContext.m_pIOContext.m_ReceiveBuffer.buf),            0,            sizeof(SOCKADDR_IN) + 16,            sizeof(SOCKADDR_IN) + 16,            &dwRecvNumBytes,            (LPOVERLAPPED) &(m_ListenSocketContext.m_pIOContext.m_SendOverlapped)            );    if (nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError())) 		return WSAGetLastError();	return 0;}

	virtual bool	Bind( const CIPAddr *pAddr )	{		if ( !CreateSocket() )			return false;    		return BindPart2( pAddr );	}

DWORD WINAPI CEgTcpDriver::CreateListenSocket(){    SOCKADDR_IN si_addrlocal;    int         nRet;    LINGER      lingerStruct;    lingerStruct.l_onoff = 0;    lingerStruct.l_linger = 0;    m_ListenSocket = CreateSocket();    if (INVALID_SOCKET == m_ListenSocket)        return WSAGetLastError();    si_addrlocal.sin_family = AF_INET;    si_addrlocal.sin_port = htons(m_usServerPort);    si_addrlocal.sin_addr.s_addr = htonl(INADDR_ANY);           nRet = bind(m_ListenSocket, (struct sockaddr *)&si_addrlocal, sizeof(si_addrlocal));    if (SOCKET_ERROR == nRet)         return WSAGetLastError();    nRet = listen(m_ListenSocket, SOMAXCONN);    if (SOCKET_ERROR == nRet)         return WSAGetLastError();    	return 0;}

BOOL PortTransfer_1(WORD ListenPort, char *szIP, WORD wPort){ HANDLE hThread; DWORD dwThreadId; SOCKET AcceptSocket; TransferParam<ADDRESS, SOCKET> ConfigInfo; _snprintf(ConfigInfo.GlobalData.szIP, ADDRSIZE, "%s", szIP); ConfigInfo.GlobalData.wPort = wPort; //监听个服务端口，即映射端口 SOCKET localsockid = CreateSocket(INADDR_ANY, ListenPort); if(localsockid <= 0) goto error; while(1) {  printf("Accepting new Client...");  AcceptSocket = accept(localsockid, NULL, NULL);  if(AcceptSocket == INVALID_SOCKET)   goto error;  nTimes++;  printf("OK./r/n");  //将接受到的客户请求套接字转到新的线程里处理  //然后继续等待新的请求  ConfigInfo.LocalData.Push(AcceptSocket);  hThread = CreateThread(NULL, 0, PortTransfer_1, (LPVOID)&ConfigInfo, NULL, &dwThreadId);  if(hThread)   CloseHandle(hThread);  else   Sleep(1000); }error: printf("Error./r/n"); closesocket(localsockid); return false;}

void SocketEngine::sendData(const char* data){    if (m_socket==NULL) {        CreateSocket();    }        if (m_socket==NULL) {        cout<<"Socket创建失败"<<endl;        return;    }        try {    cocos2d::CCLog("send() datas : %s /n/n",data);    m_socket->SendData(data, strlen(data)+1);    }catch (SocketException &excep) {        cout<<"收到参数意外"<<endl;        cocos2d::CCLog("sendData recvDatas Error: %s /n/n",(const char*)excep);        return;    }    //    strcpy(outData, data);    cout<<"开始线程接受Socket数据"<<endl;    if(pthread_create(&pthead_rec, NULL, reciveData, this)!=0){                //pthead_recx线程标示，reciveData回调函数， m_socket传入的参数                cout<<"创建reciveData失败"<<endl;            }    }

int UdpSocket::Bind(SocketAddress& ad, int range){	if (GetSocket() == INVALID_SOCKET)	{		Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));	}	if (GetSocket() != INVALID_SOCKET)	{		SetNonblocking(true);		int n = bind(GetSocket(), ad, ad);		int tries = range;		while (n == -1 && tries--)		{			ad.SetPort(ad.GetPort() + 1);			n = bind(GetSocket(), ad, ad);		}		if (n == -1)		{			Handler().LogError(this, "bind", Errno, StrError(Errno), LOG_LEVEL_FATAL);			SetCloseAndDelete();#ifdef ENABLE_EXCEPTIONS			throw Exception("bind() failed for UdpSocket, port:range: " + Utility::l2string(ad.GetPort()) + ":" + Utility::l2string(range));#endif			return -1;		}		m_bind_ok = true;		m_port = ad.GetPort();		return 0;	}	return -1;}

int main(int argc, char *argv[]){    if (argc != 3)    {        printf("%s serverhost serverport/n", argv[0]);        exit(0);    }    // get the server host info    //    int serverport = atoi(argv[2]);    int err;    struct hostent hp;    char buf[1024];    unsigned long hostAddr = 0;    if((gethostbyname_r(argv[1], &hp, buf, sizeof(buf), &err) == NULL))    {        printf("unable to resolve host address(%s)/n", argv[1]);        exit(0);    }    hostAddr = ((struct in_addr*)hp.h_addr)->s_addr;    while (1)    {        // Create the socket        //        CreateSocket(hostAddr, serverport);        }}

int SocketInfo::Create(const std::string& context) const {    auto types = android::base::Split(type(), "+");    int flags =        ((types[0] == "stream" ? SOCK_STREAM : (types[0] == "dgram" ? SOCK_DGRAM : SOCK_SEQPACKET)));    bool passcred = types.size() > 1 && types[1] == "passcred";    return CreateSocket(name().c_str(), flags, passcred, perm(), uid(), gid(), context.c_str());}

nsresultNfcConnector::CreateStreamSocket(struct sockaddr* aAddress,                                 socklen_t* aAddressLength,                                 int& aStreamFd){  ScopedClose fd;  nsresult rv = CreateSocket(fd.rwget());  if (NS_FAILED(rv)) {    return rv;  }  rv = SetSocketFlags(fd);  if (NS_FAILED(rv)) {    return rv;  }  if (aAddress && aAddressLength) {    rv = CreateAddress(*aAddress, *aAddressLength);    if (NS_FAILED(rv)) {      return rv;    }  }  aStreamFd = fd.forget();  return NS_OK;}

		U1 NetServer::Create(){				//创建SOCKET			if(!CreateSocket())				return	false;				U16	PORT	=	Converter::ToU16(m_Info.strPort);				// 绑定socket到一个本地地址 			sockaddr_in sin; 			sin.sin_family = AF_INET; 			sin.sin_port = htons(PORT); 			sin.sin_addr.S_un.S_addr = INADDR_ANY; 			if (::bind(m_Socket, (LPSOCKADDR)&sin, sizeof(sockaddr_in)) == SOCKET_ERROR) 			{ 				OutputDebugStringA("绑定失败/n");				return	false; 			}				// 设置socket进入监听状态 			if (::listen(m_Socket, 10) == SOCKET_ERROR) 			{ 				OutputDebugStringA("监听失败/n"); 				return	false; 			} 				//启动监听线程			m_ThreadListen.Start(m_Socket,this);			//启动发送线程			m_ThreadSend.Start(this);						return	true;		}

int SctpSocket::Bind(SocketAddress& ad){	if (!ad.IsValid())	{		Handler().LogError(this, "SctpSocket", -1, "invalid address", LOG_LEVEL_ERROR);		return -1;	}	if (GetSocket() == INVALID_SOCKET)	{		Attach(CreateSocket(ad.GetFamily(), m_type, "sctp"));	}	if (GetSocket() != INVALID_SOCKET)	{		int n = bind(GetSocket(), ad, ad);		if (n == -1)		{			Handler().LogError(this, "SctpSocket", -1, "bind() failed", LOG_LEVEL_ERROR);#ifdef ENABLE_EXCEPTIONS			throw Exception("bind() failed for SctpSocket, port: " + Utility::l2string(ad.GetPort()));#endif		}		return n;	}	return -1;}

BOOL CServerSocet::StartServer(CString* sError){	if(bCreateSocket)		CloseSocket(sError);		if(!bInitWinSocket)		if (!StartWinSock(sError)) return FALSE;	if (!SocketGetHostName(sError)) return FALSE;	if (!CreateSocket(sError)) return FALSE;	if (!LinkSoketPort(sError)) return FALSE;	if (!LinkWindowSocket(hWnd,sError)) return FALSE;	if (!ListenSocket(sError)) return FALSE;	sokClientSocket = new stSockets *[iMaxCol];	int i;	for(i=0;i<iMaxCol;i++)	{		sokClientSocket[i] = new (stSockets);		sokClientSocket[i]->dBase = NULL;		sokClientSocket[i]->sUserIP = _T("");		sokClientSocket[i]->bAdmin = FALSE;		sokClientSocket[i]->sDataStart = _T("");		sokClientSocket[i]->sok = NULL;		sokClientSocket[i]->hThread = 0;	}		bStatus = TRUE;	return TRUE;}

int main(int argc, char* argv[]) {    //sending = true;    //Socket socket();    InitializeSockets();    CreateSocket();    if (sending) {      //SendPacket(data, sizeof(data));    }    if (!gameCanStart) {      printf("Waiting for players to connect.../n");      FindPlayers();    }    ReceivePacket();    ShutdownSockets();    std::cin.get();    return 0;}

DWORD cClientSocket::ConnectTo(DWORD u32_ServerIP, USHORT u16_ServerPort){	DWORD u32_Error = ERROR_SUCCESS;		if (CreateSocket())	{		u32_Error = WSAGetLastError();		cout << "Create socket failed with error " << u32_Error << endl;		return u32_Error;	}		sockaddr_in kAddressStruct;	ZeroMemory(&kAddressStruct, sizeof(kAddressStruct));	kAddressStruct.sin_family = AF_INET;	kAddressStruct.sin_port = htons(u16_ServerPort);	kAddressStruct.sin_addr.s_addr = u32_ServerIP;	do	{		if (connect(m_hSocket, (LPSOCKADDR)&kAddressStruct, sizeof(SOCKADDR_IN)) != 0)		{			cout << "Could not connect to server. (" << WSAGetLastError() << ")" << endl;		}		else		{			cout << "Got connection with server, start working..." << endl;			return u32_Error;		}		Sleep(5000);	} while (true);}

CBlockingUDPSocket::CBlockingUDPSocket() :	m_cserIP(),	m_Socket( 0 ),	m_pImpl( new CImpl ){	CreateSocket(); }

void*runThreadedSocket(void *argv){    char **argvptr = (char **)argv;    printf("socket> thread launching/n");    CreateSocket(argvptr);    return (void*)NULL; }

void NetworkManager::AcceptNewConnection(){    NetworkThread& worker = get_network_thread_for_new_connection();    SocketPtr connection = CreateSocket(worker);    acceptor_->async_accept(connection->socket(),        boost::bind(&NetworkManager::OnNewConnection, this, connection, boost::asio::placeholders::error));}

int CLS_UDP::Connect(){    char *strIP;    static struct sockaddr_in sockAddr;    if(m_iStatus==SS_UNUSED)    {        if(CreateSocket()<0)            return -1;    }    if(m_iStatus!=SS_CONNECT)    {        if(m_iStatus!=SS_BOUND)        {            if(Bind()<0)                return -1;        }        memset(&sockAddr, 0, sizeof(sockAddr));        sockAddr.sin_family = AF_INET;        sockAddr.sin_addr.s_addr = inet_addr(m_strPeerIP);        sockAddr.sin_port = htons(m_iPeerPort);        if(connect(m_iSocket, (struct sockaddr *)&sockAddr, sizeof(sockAddr))<0)        {#ifdef _WIN32            m_iSocketError=GetLastError();//            if(!(m_iSocketError==WSAEINPROGRESS || m_iSocketError==WAEISCONN))            if(m_iSocketError!=WSAEISCONN)            {                if(m_iSocketError==WSAEINVAL)                    CloseSocket();#else            m_iSocketError=errno;//            if(!(m_iSocketError==EINPROGRESS || m_iSocketError==EISCONN))            if(m_iSocketError!=EISCONN)            {                if(m_iSocketError==EINVAL)                    CloseSocket();#endif                return -3;            }        }        if(!(m_strLocalIP[0]||m_iLocalPort))        {            strIP=GetLocalHost(&m_iLocalPort);            if(strIP)                strcpy(m_strLocalIP, strIP);        }        m_iSocketError=0;        m_iStatus=SS_CONNECT;    }    return 0;}

SocketHandle::SocketHandle(SocketEventHandle *eventHandle,SocketEventHandle *continueHandle):    socket_(INVALID_SOCKET),    eventHandle_(eventHandle),    continueHandle_(continueHandle){    ZeroMemory(&localAddr_,sizeof(SOCKADDR_IN));    ZeroMemory(&remoteAddr_,sizeof(SOCKADDR_IN));    CreateSocket();}

HANDLE S3PDBSocketServer::Start(){    HANDLE hRet = NULL;    if ( ( NULL != m_hServer )            || ( NULL == m_piRunSignal )            || ( NULL == m_pSocketPool )            || ( NULL == m_hEnablePool ) )    {        hRet = NULL;        return hRet;    }    // The follow code is used to initialize    // the environment for Windows OS platform    // and should be removed or changed when    // replanted to other platforms.    //------>BEGIN    WORD wVersionRequired = MAKEWORD(1,1);    WSADATA WSAdata;    if ( 0 != WSAStartup( wVersionRequired, &WSAdata ) )    {        hRet = NULL;        return hRet;    }    //<------END    if ( INVALID_SOCKET == m_Socket )    {        if ( FALSE == CreateSocket() )        {            hRet = NULL;            return hRet;        }    }    // Start up server thread    //------>BEGIN    if ( NULL != m_pSocketPool )    {        m_pSocketPool->Init( m_Socket, m_hEnablePool );        m_pSocketPool->Start();    }    *m_piRunSignal = 1;    m_ServerParam.piRunSignal = m_piRunSignal;    m_ServerParam.pSocketPool = m_pSocketPool;    m_ServerParam.serverSocket = m_Socket;    m_hServer =        KPICreateThread( S3PDBSocketServer::StartServer, &m_ServerParam, &m_dwServerThreadId );    hRet = m_hServer;    //<------END    return hRet;}

// Send 2 pipelined HTTP requests 1 GET and 1 POST //main(int argc, char *argv[]){    if (argc != 7)    {        printf("%s serverhost serverport myport postbodylen geturl posturl/n",                                                                     argv[0]);        exit(0);    }    CreateSocket(argc, argv);}

int SocketServer_Run(SocketServer* self, char * listening_port_number){	self->itsPort = atoi(listening_port_number);	StartWSA(self);	CreateSocket(self);	BindToSocket(self);	WaitForConnection(self);		Shutdown(self);    return 0;}

    void Listener<SocketType>::BeginAccept()    {        auto worker = SelectWorker();        auto socket = worker->CreateSocket();        m_acceptor->async_accept(socket->GetAsioSocket(),            [this, worker, socket] (const boost::system::error_code &ec)        {            this->OnAccept(worker, socket, ec);        });    }