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

void sigint_handler(int signum){    // do cleanups here and free all existing variables and stuff    log_out("Closing client on: %d.../n", socket_get_fd(s));    socket_close(s);    exit(signum);}

/** * netplay_new: * @server               : IP address of server. * @port                 : Port of server. * @frames               : Amount of lag frames. * @cb                   : Libretro callbacks. * @spectate             : If true, enable spectator mode. * @nick                 : Nickname of user. * * Creates a new netplay handle. A NULL host means we're * hosting (user 1). * * Returns: new netplay handle. **/netplay_t *netplay_new(const char *server, uint16_t port,                       unsigned frames, const struct retro_callbacks *cb,                       bool spectate,                       const char *nick){    netplay_t *netplay = NULL;    if (frames > UDP_FRAME_PACKETS)        frames = UDP_FRAME_PACKETS;    netplay = (netplay_t*)calloc(1, sizeof(*netplay));    if (!netplay)        return NULL;    netplay->fd                = -1;    netplay->udp_fd            = -1;    netplay->cbs               = *cb;    netplay->port              = server ? 0 : 1;    netplay->spectate.enabled  = spectate;    netplay->is_server         = server == NULL;    strlcpy(netplay->nick, nick, sizeof(netplay->nick));    if(spectate)        netplay->net_cbs = netplay_get_cbs_spectate();    else        netplay->net_cbs = netplay_get_cbs_net();    if (!init_socket(netplay, server, port))    {        free(netplay);        return NULL;    }    if(!netplay_info_cb(netplay, frames))        goto error;    return netplay;error:    if (netplay->fd >= 0)        socket_close(netplay->fd);    if (netplay->udp_fd >= 0)        socket_close(netplay->udp_fd);    free(netplay);    return NULL;}

voidudp_detach(struct socket *so){	socket_close(so->s);	/* if (so->so_m) m_free(so->so_m);    done by sofree */	sofree(so);}

void ThreadedSocketConnection::disconnect(){ QF_STACK_PUSH(ThreadedSocketConnection::disconnect)    m_disconnect = true;  socket_close( m_socket );  QF_STACK_POP}

/* * Used to kill the server properly when receiving SIGINT (^C). * TODO : this function should also kill all living sons of the main process, * and close the associated sockets. * (Should we store their pids in a global array ?) */static void kill_server (int signum){    /* Dummy assignment to shut the compiler up */    signum = signum;    socket_close (server_socket);    exit (EXIT_SUCCESS);}

/** Deinitialize and free Netplay discovery */void deinit_netplay_discovery(void){   if (lan_ad_client_fd >= 0)   {      socket_close(lan_ad_client_fd);      lan_ad_client_fd = -1;   }}

void irc_disconnect (irc_session_t * session){	if ( session->sock >= 0 )		socket_close (&session->sock);	session->sock = -1;	session->state = LIBIRC_STATE_INIT;}

static int net_http_new_socket(const char *domain, int port){   int fd;#ifndef _WIN32   struct timeval timeout;#endif   struct addrinfo hints, *addr = NULL;   char portstr[16] = {0};   snprintf(portstr, sizeof(portstr), "%i", port);   memset(&hints, 0, sizeof(hints));   hints.ai_family   = AF_UNSPEC;   hints.ai_socktype = SOCK_STREAM;   hints.ai_flags    = 0;   if (getaddrinfo_rarch(domain, portstr, &hints, &addr) < 0)      return -1;   if (!addr)      return -1;   fd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);#ifndef _WIN32   timeout.tv_sec=4;   timeout.tv_usec=0;   setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof timeout);#endif   if (connect(fd, addr->ai_addr, addr->ai_addrlen) != 0)   {      freeaddrinfo_rarch(addr);      socket_close(fd);      return -1;   }   freeaddrinfo_rarch(addr);   if (!socket_nonblock(fd))   {      socket_close(fd);      return -1;   }   return fd;}

void ssl_socket_close(void *state_data){   struct ssl_state *state = (struct ssl_state*)state_data;   mbedtls_ssl_close_notify(&state->ctx);   socket_close(state->net_ctx.fd);}

void server_pensionerHtmlID(socket_t * client, resource_t * lt, http_request_t * req){    char buf[10000] = "";    char * p = strstr(req->uri, "/pensioners/");    p = p + 12;    int index = atoi(p);    if(index >= 0)    {        for(int i = 0; i < resource_getCnt(lt); i++)        {            if(index == resource_getID(lt, i))            {                if(strcmp(req->method, "GET") == 0)                {                    char pText[1000] = "";                    char * text = pensioner_toHTML(resource_getbyId(lt, index), index);                    strcat(pText, text);                    char * pageText = "<a href=/"http://127.0.0.1:5000/pensioners/"><br>Back to the list.</a>";                    strcat(pText, pageText);                    char * textHtml = textToBuf_HTML(pText);                    strcat(buf, textHtml);                    free(textHtml);                }                else if(strcmp(req->method, "DELETE") == 0)                {                    char pText[1000] = "";                    char * text = pensioner_toHTML(resource_deletePens(lt, index), index);                    strcat(pText, text);                    free(text);                    sprintf(buf,                            "HTTP/1.1 200 OK/n"                            "Access-Control-Allow-Origin: */n"                            "Access-Control-Allow-Methods: DELETE/n"                            "/n");                }            }        }        char * message = "<h3 style=/"color:orange/">ID not found!</h3>";        char * textHtml = textToBuf_HTML(message);        strcat(buf, textHtml);        free(textHtml);    }    else    {        char * message = "<h3 style=/"color:orange/">ID not found!</h3>";        char * textHtml = textToBuf_HTML(message);        strcat(buf, textHtml);        free(textHtml);    }    socket_write_string(client, buf);    socket_close(client);}

static void server_post(http_request_t request, socket_t* client, leading_t** leadings){    int id = 0;    int count = leading_leadingsCount(leadings);    char buffer[2000] ="";    char* str;    char* name = http_request_getArg(&request, "name");    char* surname = http_request_getArg(&request, "surname");    char* birthdate = http_request_getArg(&request, "birthdate");    char* experience = http_request_getArg(&request, "experience");    char* rating = http_request_getArg(&request, "rating");    if(strlen(name) <= 1 || strlen(surname) <= 1 || strlen(birthdate) <= 1){        server_send(client, "Name/Surname/Birthday wasn't filled in"                            "<p><a href=/"/leadings/new//">Back to POST</a></p>");        return;    }    str = birthdate;   if(strlen(birthdate) > 10 || str[4] != '-' || str[7] != '-' || isdigit(birthdate[0])==0 || isdigit(experience[0]) == 0 || isdigit(rating[0])==0){        server_send(client, "Wrong data!"                    "<p><a href=/"/leadings/new//">Back to POST</a></p>");        return;    }    if(experience == " ")        experience = "0";    if(rating == " ")        rating = "0.0";    if(count >= MAX_LEADINGS){        char fail[] = "Limit of leadings!";        sprintf(buffer,            "HTTP/1.1 404 /n"            "Content-Type: text/n"            "Content-Length: %i/r/n/r/n"            "/n%s", strlen(fail), fail);        socket_write_string(client, buffer);        socket_close(client);        return;    }    for(int i = 0; i<MAX_LEADINGS; i++, id++)    {        if(leading_getId(leadings[i]) == -1)            break;    }    int exp = atoi(experience);    double rate = atof(rating);    leading_fill(leadings[id], id, name, surname, birthdate, exp, rate);    server_send(client, "Success"                "<p><a href=/"/leadings//">All leadings</a></p>");}

int socket_tcp_listen(const char *hostname, const char *port) {	// NULL port / service name is not accepted.	// NULL hostname is OK. (== bind to any interface)	if (!port) {		return -1;	}	struct addrinfo *address, hints;	memset(&hints, 0, sizeof(hints));	hints.ai_family = AF_INET6;	hints.ai_socktype = SOCK_STREAM;	hints.ai_flags = AI_PASSIVE | AI_ALL | AI_V4MAPPED;	int r = -1;		if (0 != (r = getaddrinfo(hostname, port, &hints, &address))) {		return -1;	}	int fd = -1;	for (struct addrinfo *iter = address; iter; iter = iter->ai_next) {		if (-1 == (fd = socket(iter->ai_family, iter->ai_socktype, address->ai_protocol))) {			perror("socket");			continue;		}		int yes = 1;		if (-1 == setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes))) {			perror("setsockopt");			socket_close(&fd);			continue;		}		if (-1 == bind(fd, iter->ai_addr, iter->ai_addrlen)) {			perror("bind");			socket_close(&fd);			continue;		}		if (-1 == listen(fd, 128)) {			perror("listen");			socket_close(&fd);		}		// Success		break;	}	freeaddrinfo(address);	return fd;}

int nettest5(void){	int err;	sockaddr addr;	int new_fd;	fd = socket_create(SOCK_PROTO_TCP, 0);	printf("created socket, fd %d/n", fd);	if(fd < 0)		return 0;	memset(&addr, 0, sizeof(addr));	addr.addr.len = 4;	addr.addr.type = ADDR_TYPE_IP;	addr.port = 1900;	NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(0,0,0,0);	err = socket_bind(fd, &addr);	printf("socket_bind returns %d/n", err);	if(err < 0)		return 0;	err = socket_listen(fd);	printf("socket_listen returns %d/n", err);	if(err < 0)		return 0;	new_fd = socket_accept(fd, &addr);	printf("socket_accept returns %d/n", new_fd);	if(new_fd < 0)		return 0;	err = socket_write(new_fd, "hello world!/n", strlen("hello world!/n"));	printf("socket_write returns %d/n", err);	printf("sleeping for 5 seconds/n");	usleep(5000000);	printf("closing fd %d/n", new_fd);	socket_close(new_fd);	printf("closing fd %d/n", fd);	socket_close(fd);	return 0;}

int main(int argc, char* argv[]) {  gint error = 0;  options_init(argc - 1, argv + 1);  INFO("Starting up.");  descriptor_init();  DEBUG("Disabling SIGPIPE.");  signal(SIGPIPE, SIG_IGN);  DEBUG("Creating ZeroMQ context.");  gpointer zmq_context = zmq_init(options_zmq_io_threads());  if (zmq_context == NULL) {    PERROR("main(zmq_init)");    error = 1;    goto err0;  }  DEBUG("Creating server on port %s.", options_port());  gint socket = socket_server(options_port());  if (socket == -1) {    error = 1;    goto err1;  }  INFO("Initialising Lua API.");  lua_api_init(zmq_context, argc - 1, argv + 1);  lua_State* lua = lua_api_get();  DEBUG("Running " LUA_START_FILE);  if (luaL_dofile(lua, LUA_START_FILE) == 1) {    ERROR("%s", lua_tostring(lua, -1));    error = 1;    goto err2;  }  io_mainloop(socket); err2:  DEBUG("Closing server socket.");  socket_close(socket); err1:  DEBUG("Terminating ZeroMQ context.");  /* This is separate from lua_api_deinit() to prevent zmq_term() from     blocking forever. */  lua_zmq_deinit();  zmq_term(zmq_context); err0:  DEBUG("Enabling SIGPIPE.");  signal(SIGPIPE, SIG_DFL);  options_deinit();  descriptor_deinit();  if (lua_api_get() != NULL) {    DEBUG("Closing Lua state.");    lua_api_deinit();  }  return error;}

void listener_release(struct listener *self) {	assert(self != NULL);	assert(!self->isfree);	if (!self)		return;	socket_close(&self->sockfd);	self->isfree = true;	netpool_releaselisten(self);}

static intst_local_socket_close(int sd){	if (!use_obp) {		return (socket_close(sd));	} else {		return (0);	}}

void player_close(player_info_t *player) {	socket_close(player->socket);	if ( player == players ) {		players = player->next;	} else {		player->prev->next = player->next;	}	free(player);}

void net_http_delete(struct http_t *state){   if (!state)      return;   if (state->fd >= 0)      socket_close(state->fd);   free(state);}

static void ClientNetworkLayerClose(UA_Connection *connection) {    if(connection->state == UA_CONNECTION_CLOSED)        return;    connection->state = UA_CONNECTION_CLOSED;    socket_close(connection);#ifndef UA_MULTITHREADING    UA_ByteString_delete(connection->handle);#endif}

int ipc_server_close(int fd, int last_error){    int ret = 0;        if (!last_error)	ret = ipc_server_sync(fd);    socket_close(fd);    return ret;}

void rarch_cmd_free(rarch_cmd_t *handle){#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)   if (handle && handle->net_fd >= 0)      socket_close(handle->net_fd);#endif   free(handle);}

static int tcp_close(FdMigrationState *s){    dprintf("tcp_close/n");    if (s->fd != -1) {        socket_close(s->fd);        s->fd = -1;    }    return 0;}

static int socket_dev_close(dev_cookie cookie){	socket_dev *s = (socket_dev *)cookie;	if(s->id >= 0)		return socket_close(s->id);	else		return 0;}

/* * Test a single listening socket.  Accepts one connection and invokes * test_server_connection.  For skipping purposes, this produces two tests. */static voidtest_server_accept(socket_type fd){    socket_type client;    client = accept(fd, NULL, NULL);    test_server_connection(client);    socket_close(fd);}

void pbpal_free(pubnub_t *pb){    if (pb->pal.socket != SOCKET_INVALID) {        /* While this should not happen, it doesn't hurt to be paranoid.         */        pbntf_lost_socket(pb, pb->pal.socket);        socket_close(pb->pal.socket);    }}

int main() {    lib_init();    list_t* list=list_new();    lanser * freeLanser[10];    for (int i = 0; i < 10; i++)        freeLanser[i] = Freelanser_new();  //  parse(freeLanser);    socket_t * serverSocket = socket_new();    socket_bind(serverSocket, 5000);    socket_listen(serverSocket);   while (1) {        socket_t * clientSocket = socket_accept(serverSocket);        char buf[10000]="";        if (!socket_read(clientSocket, buf, sizeof(buf))) {            puts("Skipping empty request");            socket_close(clientSocket);            socket_free(clientSocket);            continue;        }        http_request_t req = http_request_parse(buf);        server_answer(list,req,clientSocket,freeLanser);        socket_close(clientSocket);        socket_free(clientSocket);    }    socket_close(serverSocket);    socket_free(serverSocket);    lib_free();    list_free(list);    return 0;}

/**unsigned short  get_valid_rtp_pair_sockets(int min, int max, int* rtp, int* rtcp)min
C++ socket_connect函数代码示例
C++ socket_accept函数代码示例