C++ createSocket函数代码示例

int main(int argc, const char *argv[])
{
    void *context = zmq_ctx_new();

    assert(argc == 4);
    void *subWildcardSock = createSocket(context, argv[1], ZMQ_SUB);
    void *pubFilenamesSock = createSocket(context, argv[2], ZMQ_PUB);
    void *subDoneSock = createSocket(context, argv[3], ZMQ_SUB);

    std::cout << "Sockets connected" << std::endl;

    bool done = false;
    std::vector<void*> sockets;
    sockets.push_back(subWildcardSock);
    sockets.push_back(subDoneSock);
    while (!done)
    {
        switch (demultiplexSockets(sockets))
        {
        case 0:
            processWildcards(subWildcardSock, pubFilenamesSock);
            break;
        case 1:
            processDone(subDoneSock);
            done = true;
            break;
        };
    }

    zmq_close(subWildcardSock);
    zmq_close(pubFilenamesSock);
    zmq_close(subDoneSock);
}

NetworkSocket::NetworkSocket(const ENetworkProtocols Protocol) :
    Protocol_   (Protocol       ),
    Socket_     (INVALID_SOCKET )
{
    createSocket();
    setupBehavior();
}

/******************************************
 * Initialisieren und starten des Servers
 */
void* handleServer(){
  #ifdef _DEBUG
  fprintf(stderr,"++ handleserver\n");
  #endif
  char    bOK         = TRUE;
  int     sProxyClient= ~0,
          sProxyWait  = ~0;
  struct  sockaddr_in saAddress;
  struct  threadParam *pThreadParam;

  if(!generateProxyAddress(&saAddress))             return NULL;
  if(!createSocket        (&sProxyWait))            return NULL;
  if(!bindSocket          (&sProxyWait,&saAddress)) return NULL;
  if(!listenSocket        (&sProxyWait))            return NULL;

  //Endlos-schleife fuer accepts
  while(1){
    bOK=acceptSocket(sProxyWait,&sProxyClient);
    if(bOK==TRUE){
      #ifdef _DEBUG
      fprintf(stderr,"***threadNewClient %d\n",sProxyClient);
      #endif
      pThreadParam=(struct threadParam*)malloc(sizeof(struct threadParam));
      pThreadParam->socketID=sProxyClient;
      threadNewClient((void*)pThreadParam);
    }
  }
  closesocket(sProxyWait);

  #ifdef _DEBUG
  fprintf(stderr,"-- handleserver\n");
  #endif
}

/*************************************************************
   This function creates datagram sockets for
   all routers directly connected to this router (input argument)

   Populates the neighborSocketArray   
   When done, static variable count contains the number of neighbor routers
   stored in the array
   Returns a pointer to the neighborSocketArray
**************************************************************/
neighborSocket* createConnections(char* routerName)
{
	int i,j;
	int socket;
	char *sourcehost, *desthost;
	int port, sourceport, destport;

	if (count != 0)
	{
		return neighborSocketArray;
	}

	// Find details for routerName from routerInfoTable
	for(i=0;i<routercount;i++)
	{
		if(strcmp(routerName,routerInfoTable[i].router) == 0)
			break;
	}

	// Get source hostname for routerName
	sourcehost = (char*)malloc(strlen(routerInfoTable[i].host)+1);
	strcpy(sourcehost,routerInfoTable[i].host);

	// Getbaseport for routerName
	port = routerInfoTable[i].baseport;

	// For all routers directly connected to me (present in linkInfoTable)
	for(i=0;i<linkcount;i++)
	{
		// Find details for this connected router
		for(j=0;j<routercount;j++)
		{
			if(strcmp(linkInfoTable[i].router,routerInfoTable[j].router) == 0)
				break;
		}

		// Get the destination host name
		desthost = (char*)malloc(strlen(routerInfoTable[j].host)+1);
		strcpy(desthost,routerInfoTable[j].host);

		// Calculate destination port number (destination baseport + remotelink)
		destport = routerInfoTable[j].baseport + linkInfoTable[i].remotelink;

		// Calculate source port number (source baseport + locallink)
		sourceport = port + linkInfoTable[i].locallink;

		// Create connected Datagram socket and get socket descriptor
		socket = createSocket(sourcehost, sourceport, desthost, destport);
		
		// Store neighbor router name and socket descriptor in neighborSocketArray
		neighborSocketArray[count].neighbor = (char*)malloc(strlen(linkInfoTable[i].router)+1);
		strcpy(neighborSocketArray[count].neighbor,linkInfoTable[i].router);
		neighborSocketArray[count].socket = socket;

		// Increment the neighborSocket Pair count
		count++;
	}

	return neighborSocketArray;
}

/* readURL(url) - access to the specified URL and stores the info read in 'data_URL' variable
 *
 * This function access to the specified URL and stores the info read in 'data_URL' variable
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * It stores in 'socket_ID' the TCP session ID assigned to the last call to create a socket
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::readURL(const char* url)
{
	char command[30];
	char* data=",20";
	uint8_t answer=0;
	long previous=0;
	uint8_t byteIN=0;
	uint8_t a=0;
	
	if(!configureGPRS()) return 0;
	
	if(!createSocket(url,"80",GPRS_CLIENT)) return 0;
	
	serialFlush(PORT_USED);
	sprintf(command,"%s%c%c","GET / HTTP/1.0",'\r','\n');
	if(!sendData(command,socket_ID)){
		closeSocket(socket_ID);
		return 0;
	}
		
	waitForData("+KTCP_DATA:",20,0,0);
	if(readData(socket_ID,GPRS_DATA_LENGTH)<0){
		closeSocket(socket_ID);
		return 0;
	}
	
	while(!closeSocket(socket_ID)) closeSocket(socket_ID);
	
	return 1;
}

void ServerCore::sendCommandToDevice(QString deviceUID, QVariantMap paramMap)
{
	QTcpSocket *socket = createSocket(deviceUID);

	QObject::connect(socket, &QTcpSocket::readyRead, [=]
	{
		QByteArray byteArray = socket->readAll();
		QJsonDocument jsonDoc = QJsonDocument::fromJson(byteArray);
		QJsonObject jsonObj = jsonDoc.object();

		if (jsonObj[JSON_KEY_STATUS].toInt() == STATUS_SUCCESSFUL)
		{
			QVariantMap retMap = jsonObj.toVariantMap();
			Q_EMIT commandReturned(deviceUID, retMap);
		}

		socket->disconnectFromHost();
	});

	QObject::connect(socket, &QTcpSocket::disconnected, [=]
	{
		socket->deleteLater();
	});

	QString jsonCmd = JsonGenerator::GenerateJsonCommand(TCP_COMMAND_TYPE::SEND_COMMAND_TO_DEVICE, paramMap);

	socket->write(jsonCmd.toLatin1());

	socket->waitForBytesWritten();
	socket->waitForReadyRead();
}

echoServerContext *createTcpServer(epoller *epoll, int port) {
	int s;
	struct sockaddr_in sa;

	if ((s = createSocket()) == -1) {
		oom("socket creation error : %s", strerror(errno));
		return NULL;
	}

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

	if (bind(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
		close(s);
		oom("bind error : %s", strerror(errno));
		return NULL;
	}
	if (listen(s, 511) == -1) { /* the magic 511 constant is from nginx */
		close(s);
		oom("listen error : %s", strerror(errno));
		return NULL;
	} 

	echoServerContext *server = (echoServerContext *)malloc(sizeof(echoServerContext));
	memset(server, 0, sizeof(echoServerContext));
	
	server->port = port;
	server->epoll = epoll;
	server->serverfd = s;
	return server;
}

/*
 * Constructor
 */
CUdpSock::CUdpSock( bool logging ) :
	CSock( logging ),
	_Bound( false )
{
	// Socket creation
	createSocket( SOCK_DGRAM, IPPROTO_UDP );
}

evutil_socket_t
ccnet_net_open_tcp (const struct sockaddr *sa, int nonblock)
{
    evutil_socket_t s;
    int sa_len;

    if( (s = createSocket(sa->sa_family, nonblock)) < 0 )
        return -1;

#ifndef WIN32
    if (sa->sa_family == AF_INET)
        sa_len = sizeof (struct sockaddr_in); 
    else
        sa_len = sizeof (struct sockaddr_in6);
#else
    if (sa->sa_family == AF_INET)
        sa_len = sizeof (struct sockaddr_in); 
    else
        return -1;
#endif


    if( (connect(s, sa, sa_len) < 0)
#ifdef WIN32
        && (sockerrno != WSAEWOULDBLOCK)
#endif
        && (sockerrno != EINPROGRESS) )
    {
        evutil_closesocket(s);
        s = -1;
    }

    return s;
}

int main ()
{
    logFile = new std::ofstream;
    (*logFile).open("client_tester.log", std::ios_base::app);


    testerAddr.sin_family = AF_INET;
    testerAddr.sin_port = (uint16_t) port;
    socklen_t addressLength = sizeof(sockaddr_in);
    memset(&testerAddr, 0, addressLength);

    // create bind and listen on socket
    createSocket();
    bindSocket();
    listenSocket();

    // get few commands and print them to log file and stdout?
    std::cout << "waiting to accept connection..." << std::endl;
    commandSocketFD = accept(testerSocketFD, reinterpret_cast<struct sockaddr *>(&cliAddr), &addressLength);
    ssize_t readSize = read(commandSocketFD, buff, MAX_BUFFER_LENGTH);
    std::cout << "buff: " << buff << std::endl;

    // send responses

}

/* Listen for incomoing connection from the client accpets 
 * only a maximum of 10 connections */
void setupListenSocket(int port, int *listen_socket) {
  struct sockaddr_in address;
  createServerAddrStruct(&address, port);
  createSocket(listen_socket);
  bindSocket(&address, listen_socket);
  listen(*listen_socket, MAX_PENDING_CONNECTIONS);
}

static int tcpGenericConnect(char *err, char *addr, int port, int flags) {
    int s;
    struct sockaddr_in sa;

    if ((s = createSocket(err, PF_INET)) == -1) {
        return -1;
    }
    sa.sin_family = PF_INET;/*{{{*/
    sa.sin_port = htons(port);
    if (inet_aton(addr, &sa.sin_addr) == 0) {
        struct hostent *he;
        he = gethostbyname(addr);
        if (he == NULL) {
            setError(err, "can't resolve: %s", addr);
            close(s);
            return -1;
        }
        memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
    }
    if (flags & NETWORK_CONNECT_NONBLOCK) {
        if(setNonBlock(err, s) != 0) {
            return -1;
        }
    }
    if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
        if (errno == EINPROGRESS && (flags & NETWORK_CONNECT_NONBLOCK)) {
            return s;
        }
        setError(err, "connect: %s", strerror(errno));
        close(s);
        return -1;
    }/*}}}*/
    return s;
}

static void sessionHandler(int port)
{
	struct sockaddr_in childSocket;
	socklen_t socketLen = sizeof(childSocket);
	int idx1, clientIdx;

	signal(SIGCHLD, sessionSignalHandler); /* register for the child's signal */
	if(createSocket(port) == 1)
	{
		fprintf(stderr, "sessionHandler: Unable to setup socket\n");
		exit(1);
	}

	while((clientIdx = accept(serverSocket, (struct sockaddr *)&childSocket, &socketLen)) > 0)
	{
		printf("sessionHandler: Client connection from %s, client index %d\n", inet_ntoa(childSocket.sin_addr), clientIdx);
		for(idx1=0; idx1 < MaxSessions; idx1++)
		{
			if(childPID[idx1] == 0)
			{
				serverPID[idx1] = clientIdx;
				childPID[idx1] = createChildProcess(socketService, clientIdx);
				break;
			}
		}

		if(idx1 == MaxSessions)
			fprintf(stderr, "sessionHandler: Max clients reached\n");

		socketLen = sizeof(childSocket);
	}
	shutdown(serverSocket, SHUT_RDWR);
	close(serverSocket);
}

int CSocketClient::start(int nSocketType, const char* cszAddr, short nPort,
		int nStyle)
{
	if (AF_UNIX == nSocketType)
	{
		setDomainSocketPath(cszAddr);
	}
	else if (AF_INET == nSocketType)
	{
		if (-1 == setInetSocket(cszAddr, nPort))
		{
			_DBG("set INET socket address & port fail");
			return -1;
		}
	}

	if (-1 != createSocket(nSocketType, nStyle))
	{
		if (SOCK_STREAM == nStyle)
		{
			if (-1 == connectServer())
			{
				socketClose();
				return -1;
			}
		}

		_DBG("[Socket Client] Socket connect success");
		return getSocketfd();
	}

	return -1;
}

void Udp::initAddr(u_short port, const std::string& ip) {
  close(sock_);
  memset(&addr_, 0, sizeof(addr_));
  createSocket();

  port_ = port;
  ip_ = ip;

  bool is_host = ip_.empty();

  addr_.sin_family = AF_INET;
  addr_.sin_port = htons(port_);
  
  addr_.sin_addr.s_addr
    = is_host
    ? INADDR_ANY
    : inet_addr(ip_.c_str());

  int on = 1;
  setsockopt(sock_, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

  // named the socket(bind)
  if (is_host) {
    int res = bind(sock_, (sockaddr*)&addr_, sizeof(addr_));
    if (res < 0) {
      std::cout << res << ": err bind" << std::endl;
    }
  }
}