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

/* send one packet (heartbeat) */int send_packet(void){	static long sequence;	auto char 	buf[128];	auto int 	length, retval;	#GLOBAL_INIT	{		sequence = 0;	}	/* fill the packet with interesting data (a sequence number) */	sequence++;	sprintf(buf, "SEQ=%ld",sequence);	length = strlen(buf) + 1;	/* send the packet */	retval = udp_send(&sock, buf, length);	if (retval < 0) {		printf("Error sending datagram!  Closing and reopening socket.../n");		if (sequence == 1) {			printf("   (initial ARP request may not have finished)/n");		}		sock_close(&sock);		if(!udp_open(&sock, LOCAL_PORT, resolve(REMOTE_IP), REMOTE_PORT, NULL)) {			printf("udp_open failed!/n");			exit(0);		}	}	tcp_tick(NULL);		return 1;}

void connection_close(connection_t *con){    sock_close(con->sock);    if (con->ip) free(con->ip);    if (con->host) free(con->host);    free(con);}

int sock_server_create(struct sockaddr *addr){	int fd;	int ret;	fd = sock_create();	if(fd < 0) {		return -1;	}	ret = sock_set_reuseaddr(fd);	if(ret < 0) {		goto err_server;	}	ret = sock_bind(fd, addr);	if(ret < 0) {		goto err_server;	}	ret = sock_listen(fd);	if(ret < 0) {		goto err_server;	}	return fd;err_server:	sock_close(fd);	return -1;}

SOCKET udpServerCreate (struct in_addr * localip, int port){	SOCKET	fd;	struct sockaddr_in addr;	fd = socket(AF_INET, SOCK_DGRAM, 0);	if (fd == -1) {		return EF_INVALID_SOCKET;	}	memset(&addr, 0, sizeof(struct sockaddr_in));	addr.sin_family = AF_INET;	if (localip != NULL) {		addr.sin_addr = *localip;	}	else {		addr.sin_addr.s_addr = htonl(INADDR_ANY);		}	addr.sin_port = htons(port);	if (bind(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) != 0) {		sock_close(fd);		return EF_INVALID_SOCKET;	}	return fd;}

intlibcfs_sock_accept (cfs_socket_t **newsockp, cfs_socket_t *sock){        cfs_socket_t   *newsock;        int             rc;        newsock = _MALLOC(sizeof(cfs_socket_t), M_TEMP, M_WAITOK|M_ZERO);        if (!newsock) {                CERROR("Can't allocate cfs_socket./n");                return -ENOMEM;        }        newsock->s_magic = CFS_SOCK_MAGIC;        /*         * thread will sleep in sock_accept by calling of msleep(),          * it can be interrupted because msleep() use PCATCH as argument.         */        rc = -sock_accept(C2B_SOCK(sock), NULL, 0, 0,                           libcfs_sock_upcall, newsock, &C2B_SOCK(newsock));        if (rc) {                if (C2B_SOCK(newsock) != NULL)                         sock_close(C2B_SOCK(newsock));                FREE(newsock, M_TEMP);                if ((sock->s_flags & CFS_SOCK_DOWN) != 0)                        /* shutdown by libcfs_sock_abort_accept(), fake                          * error number for lnet_acceptor() */                        rc = -EAGAIN;                return rc;        }        *newsockp = newsock;        return 0;}

void node_del_data_event(struct node *node){	int ret;	log_error("%s: del data event for node %d", __func__, node->id);	ret = pthread_spin_trylock(&node->spinlock);	if(ret != 0) {		log_error("%s: del data event get lock failed", __func__);		return;	}	if(node->data_event == NULL) {		log_error("%s: null data_event for node %d, cancel", __func__, node->id);		goto err;	}	shutdown(node->dfd, SHUT_RDWR);	sock_close(node->dfd);	node->dfd = -1;	node->data_conn_state = NODE_DFD_DISCONNECTED;	event_free(node->data_event);	node->data_event = NULL;	pthread_spin_unlock(&node->spinlock);	clean_packet_queue(node->data_q);	node_disconnect(node);	return;err:	pthread_spin_unlock(&node->spinlock);}

int Sock_close(Sock *s){    int res;    if (!s)        return -1;    if(s->flags & IS_MULTICAST) {        if (s->remote_host)            mcast_leave(s->fd,(struct sockaddr *) &(s->remote_stg));        else            mcast_leave(s->fd,(struct sockaddr *) &(s->local_stg));    }#if HAVE_SSL    if(s->flags & IS_SSL)        sock_SSL_close(s->ssl);#endif    res = sock_close(s->fd);    if (s->remote_host) free(s->remote_host);    if (s->local_host) free(s->local_host);    free(s);    return res;}

int daemon_endcapture(pcap_t *fp, pthread_t *threaddata, char *errbuf){struct rpcap_header header;SOCKET sockctrl;	if (threaddata)	{		pthread_cancel(*threaddata);		threaddata= 0;	}	if (fp->rmt_sockdata)	{		sock_close(fp->rmt_sockdata, NULL, 0);		fp->rmt_sockdata= 0;	}	sockctrl= fp->rmt_sockctrl;	pcap_close(fp);	fp= NULL;	rpcap_createhdr( &header, RPCAP_MSG_ENDCAP_REPLY, 0, 0);	if ( sock_send(sockctrl, (char *) &header, sizeof(struct rpcap_header), errbuf, PCAP_ERRBUF_SIZE) == -1)		return -1;		return 0;}

/* * Closes the TCP socket for the client (wrapper for sock_close()). */void client_disconnect_tcp(client_t* c){	if(c->connected) {		sock_close(c->tcp_sock);		c->connected = 0;	}}

int sock_destroy(SOCKINFO *info, int ShutdownMethod){	int ret = UPNP_E_SUCCESS;	char errorBuffer[ERROR_BUFFER_LEN];	if (info->socket != INVALID_SOCKET) {#ifdef UPNP_ENABLE_OPEN_SSL		if (info->ssl) {			SSL_shutdown(info->ssl);			SSL_free(info->ssl);			info->ssl = NULL;		}#endif		if (shutdown(info->socket, ShutdownMethod) == -1) {			strerror_r(errno, errorBuffer, ERROR_BUFFER_LEN);			UpnpPrintf(UPNP_INFO, HTTP, __FILE__, __LINE__,				   "Error in shutdown: %s/n", errorBuffer);		}		if (sock_close(info->socket) == -1) {			ret = UPNP_E_SOCKET_ERROR;		}		info->socket = INVALID_SOCKET;	}	return ret;}

int irc_connect(char *hostname, int port) {    int fd;    int nb;    char *buff;    char ip[IP_STR_LEN];    /* resolve hostname to ip */    nb = sock_dns(hostname, ip);    if (!nb)        return -1;    /* get connected */    fd = sock_connect(ip, port);    if (fd == -1)        return -1;    /* register with server */    buff = "NICK " IRC_NICKNAME "/r/nUSER " IRC_USERNAME " localhost server :"           IRC_REALNAME "/r/n";    nb = send(fd, buff, strlen(buff), 0);    if (nb < 0) {        sock_close(fd);        return -1;    }    pthread_mutex_init(&lock, NULL);    return fd; // persistent connection, return socket descriptor}

/*! */brief	child and parent cleanup (child closes first) * */param	session Contains session information * */return	 0 : success */static gint session_close(Session *session){	g_return_val_if_fail(session != NULL, -1);	if (session->conn_id > 0) {		sock_connect_async_cancel(session->conn_id);		session->conn_id = 0;		debug_print("session (%p): connection cancelled/n", session);	}	session_set_timeout(session, 0);	if (session->io_tag > 0) {		g_source_remove(session->io_tag);		session->io_tag = 0;	}	if (session->sock) {		sock_close(session->sock);		session->sock = NULL;		session->state = SESSION_DISCONNECTED;		debug_print("session (%p): closed/n", session);	}	return 0;}

int main(int argc, char** argv) {	if (argc != 4) {		fprintf(stderr, "%s/n", "required arguments: input file, IP address, port");		exit(-1);	}	sock_desc sock = sock_tcp_init();	sock_connect(sock, argv[2], atoi(argv[3]));	FILE* input = fopen(argv[1], "r");	char* buffer = malloc(BUFFER_SIZE);	size_t size_read = 0;	/* Send all the data from the file */	while ((size_read = fread(buffer, sizeof(char), BUFFER_SIZE, input))) {		sock_send(sock, size_read, buffer);	}	fprintf(stderr, LOG_PRE "%s/n", "file sent, closing socket");	sock_close(sock);	free(buffer);	fclose(input);}

static intlibcfs_sock_create (cfs_socket_t **sockp, int *fatal,                    __u32 local_ip, int local_port){        struct sockaddr_in  locaddr;        cfs_socket_t    *sock;        int             option;        int             optlen;        int             rc;        /* All errors are fatal except bind failure if the port is in use */        *fatal = 1;        sock = _MALLOC(sizeof(cfs_socket_t), M_TEMP, M_WAITOK|M_ZERO);        if (!sock) {                CERROR("Can't allocate cfs_socket./n");                return -ENOMEM;        }        *sockp = sock;        sock->s_magic = CFS_SOCK_MAGIC;        rc = -sock_socket(PF_INET, SOCK_STREAM, 0,                           libcfs_sock_upcall, sock, &C2B_SOCK(sock));        if (rc != 0)                 goto out;        option = 1;        optlen = sizeof(option);        rc = -sock_setsockopt(C2B_SOCK(sock), SOL_SOCKET,                               SO_REUSEADDR, &option, optlen);        if (rc != 0)                goto out;        /* can't specify a local port without a local IP */        LASSERT (local_ip == 0 || local_port != 0);        if (local_ip != 0 || local_port != 0) {                bzero (&locaddr, sizeof (locaddr));                locaddr.sin_len = sizeof(struct sockaddr_in);                locaddr.sin_family = AF_INET;                locaddr.sin_port = htons (local_port);                locaddr.sin_addr.s_addr = (local_ip != 0) ? htonl(local_ip) : INADDR_ANY;                rc = -sock_bind(C2B_SOCK(sock), (struct sockaddr *)&locaddr);                if (rc == -EADDRINUSE) {                        CDEBUG(D_NET, "Port %d already in use/n", local_port);                        *fatal = 0;                        goto out;                }                if (rc != 0) {                        CERROR("Error trying to bind to port %d: %d/n",                               local_port, rc);                        goto out;                }        }        return 0;out:        if (C2B_SOCK(sock) != NULL)                 sock_close(C2B_SOCK(sock));        FREE(sock, M_TEMP);        return rc;}

int lwip_socket(int domain, int type, int protocol) {	int s, fd;	// We only support basic internet protocols	if (domain != AF_INET || protocol != 0 || (type != SOCK_STREAM && type != SOCK_DGRAM)) {		errno = EPROTONOSUPPORT;		return -1;	}	// Allocate a new socket for it	s = sock_open();	if (s < 0) {		errno = ENFILE;		return -1;	}	fds[s].type = type;	// Make a VFS socket for it	fd = fs_open_handle(&socketvfs, (void *)(s+1));	if (fd < 0) {		sock_close(s);	}	return fd;}

int sock_open(const char* host, int port){	char szPort[10];	struct addrinfo hints;	struct addrinfo *servinfo, *p;	int rv, sockfd = -1;	sprintf(szPort, "%d", port);	memset( &hints, 0, sizeof(struct addrinfo));	hints.ai_family = AF_UNSPEC;	hints.ai_socktype = SOCK_STREAM;	hints.ai_protocol = IPPROTO_TCP;	rv = getaddrinfo(host, szPort, &hints, &servinfo);	if (rv != 0) {		printf("getaddrinfo failed: %d/n", rv);		return -1;	}	for (p = servinfo; p !=NULL; p = p->ai_next) {		if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) > 0) {			if (connect(sockfd, p->ai_addr, p->ai_addrlen) == 0) {				break;			} else {				sock_close(sockfd);				sockfd = -1;			}		}	}	freeaddrinfo(servinfo);	return sockfd;}

int try_connect_HELO(const char *hostname){    char dbg_hostname[BIG_BUF];    char dbg_version[BIG_BUF];    char buf[BIG_BUF];    char testme[BIG_BUF];    /* Try the HELO protocal */    if(my_socket != -1)        sock_close(my_socket);    if (sock_open(get_string("mailserver"), get_number("smtp-socket", 25), &my_socket))        return 0;    if (sock_readline(my_socket, buf, sizeof(buf)) == 0)        return 0;    if(!sscanf(buf,"220 %s %s", &dbg_hostname[0], &dbg_version[0]))        return 0;    log_printf(9, "Connected: %s (%s)/n", dbg_hostname, dbg_version);    sock_printf(my_socket, "HELO %s/r/n", hostname);    if(sock_readline(my_socket, buf, sizeof(buf)) == 0)        return 0;    if(!sscanf(buf, "250 %s", testme))        return 0;    return 1;}

int riack_connect(struct RIACK_CLIENT *client, const char* host, int port,		struct RIACK_CONNECTION_OPTIONS* options){	client->sockfd = sock_open(host, port);	if (client->sockfd > 0) {		if (client->host && host != client->host) {			RFREE(client, client->host);		}		if (host != client->host) {			client->host = (char*)RMALLOC(client, strlen(host)+1);			strcpy(client->host, host);		}		client->port = port;		if (options) {			client->options = *options;			if (!sock_set_timeouts(client->sockfd, options->recv_timeout_ms, options->send_timeout_ms)) {				sock_close(client->sockfd);				client->sockfd = -1;				// TODO set last error			}		}		return RIACK_SUCCESS;	}	return RIACK_ERROR_COMMUNICATION;}

intlibcfs_sock_listen (cfs_socket_t **sockp,                   __u32 local_ip, int local_port, int backlog){        cfs_socket_t    *sock;        int             fatal;        int             rc;        rc = libcfs_sock_create(&sock, &fatal, local_ip, local_port);        if (rc != 0)  {                if (!fatal)                        CERROR("Can't create socket: port %d already in use/n",                                local_port);                return rc;        }        rc = -sock_listen(C2B_SOCK(sock), backlog);        if (rc == 0) {                *sockp = sock;                return 0;        }        if (C2B_SOCK(sock) != NULL)                 sock_close(C2B_SOCK(sock));        FREE(sock, M_TEMP);        return rc;}

sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, int timeout){    sock_t sock;    sock = sock_open (AF_INET, SOCK_STREAM, 0);    if (sock == SOCK_ERROR)        return SOCK_ERROR;    if (bnd)    {        struct sockaddr_in sa;        memset(&sa, 0, sizeof(sa));        sa.sin_family = AF_INET;        if (inet_aton (bnd, &sa.sin_addr) == 0 ||                bind (sock, (struct sockaddr *)&sa, sizeof(sa)) < 0)        {            sock_close (sock);            return SOCK_ERROR;        }    }    if (timeout)    {        sock_set_blocking (sock, 0);        if (sock_try_connection (sock, hostname, port) < 0)        {            int ret = sock_connected (sock, timeout);            if (ret <= 0)            {                sock_close (sock);                return SOCK_ERROR;            }        }        sock_set_blocking(sock, 1);    }    else    {        if (sock_try_connection (sock, hostname, port) < 0)        {            sock_close (sock);            sock = SOCK_ERROR;        }    }    return sock;}

int32_t connector_stop(connector_t* con){    if (!con || con->h.fd < 0) return -1;    reactor_unregister(con->r, &con->h);    sock_close(con->h.fd);    con->h.fd = -1;    return 0;}

int riack_disconnect(struct RIACK_CLIENT *client){	if (client->sockfd > 0) {		sock_close(client->sockfd);		client->sockfd = -1;	}	return RIACK_SUCCESS;}

void plain_socket::close(bool free){	if(hSocket != INVALID_SOCKET)	{		sock_close(hSocket);		hSocket = INVALID_SOCKET;	}}

static void openloghost (void){  struct servent *sp;  struct hostent *hp;  if (logSock)  {    sock_close (logSock);    logSock = NULL;  }  sp = getservbyname ("syslog", "udp");  if (sp)     syslog_port = htons (sp->s_port);  logHost = _inet_addr (syslog_hostName);  if (!logHost)  {    hp = gethostbyname (syslog_hostName);    if (!hp)    {      fprintf (stderr, "syslog: Unknown host `%s'/n", syslog_hostName);      return;    }    logHost = ntohl (*(DWORD*)hp->h_addr);  }  if (!logSock)  {    logSock = malloc (sizeof(udp_Socket));    if (!logSock)    {      perror ("syslog");      return;    }  }  if (!udp_open ((udp_Socket*)logSock, 0, logHost, syslog_port, NULL))  {    errno = errno_s = EHOSTUNREACH;  /* "No route to host" (ARP failed) */    STAT (ipstats.ips_noroute++);    perror ("syslog");    sock_close (logSock);    logSock = NULL;  }}

void workers_adjust (int new_count){    INFO1 ("requested worker count %d", new_count);    while (worker_count != new_count)    {        if (worker_count < new_count)            worker_start ();        else if (worker_count > new_count)            worker_stop ();    }    if (worker_count == 0)    {        logger_commits(0);        sock_close (logger_fd[1]);        sock_close (logger_fd[0]);    }}

/* * Close socket if MSG_EOR specified in flags. */static __inline void msg_eor_close (Socket *socket){  switch (socket->so_type)  {    case SOCK_STREAM:         socket->so_state |= SS_CANTSENDMORE;         sock_close ((sock_type*)socket->tcp_sock);         break;    case SOCK_DGRAM:         socket->so_state |= SS_CANTSENDMORE;         sock_close ((sock_type*)socket->udp_sock);         break;    case SOCK_RAW:         socket->so_state |= SS_CANTSENDMORE;         break;  }}

/* * Send the response to the remote machine */void SendMessage(tcp_Socket *tcpSock, unsigned key, char* messages[]){    sock_write(tcpSock, messages[key], strlen(messages[key])+1);    sock_close(tcpSock);    while (tcp_tick(tcpSock) != 0);    return;}

int sock_epoll_wait(int timeout) {	int n, i;	time_t epoll_time;	struct epoll_event *cevents;	for( ; ; )    {		n = epoll_wait(ct.efd, ct.events, ct.max_events, timeout);		if(n <= 0) continue;						// check timeout 		epoll_time = time((time_t*)0);		for(i = 0; i <= server.maxfd; i++)		{			struct conn_t *c = &server.conn[i];			if(c->fd &&  (c->fd != server.listen_fd) && (epoll_time > (c->now + SOCK_TIMEOUT)))			{				sock_close(c->fd);			}		}				for (i = 0, cevents = ct.events; i < n; i++, cevents++) 		{				if(cevents->events & (EPOLLHUP | EPOLLERR) && cevents->data.fd != server.listen_fd)			{				sock_close(cevents->data.fd);			}			else if(cevents->events & EPOLLIN && cevents->data.fd == server.listen_fd)			{				http_request_accept(cevents->data.fd);			}			else if(cevents->events & EPOLLIN)			{				http_request_read(cevents->data.fd);			}			else if(cevents->events & EPOLLOUT)			{				http_request_write(cevents->data.fd);			}		}    }}

voidlibcfs_sock_release (cfs_socket_t *sock){        if (C2B_SOCK(sock) != NULL) {                sock_shutdown(C2B_SOCK(sock), 2);                sock_close(C2B_SOCK(sock));        }        FREE(sock, M_TEMP);}

/*! * /brief Free memory assigned for handling request and unitialize socket * functionality. */static void free_handle_request_arg(	/*! [in] Request Message to be freed. */	void *args){	struct mserv_request_t *request = (struct mserv_request_t *)args;	sock_close(request->connfd);	free(request);}