C++ close_socket函数代码示例

///----------------------------------------------------------------------------
void socket::connect(yield_t yield)
{
  if (sending_)
  {
    reconn_ = true;
  }
  close_socket();
  boost::asio::ip::tcp::resolver::query query(host_, port_);
  boost::asio::ip::tcp::resolver::iterator itr = reso_.async_resolve(query, yield);
  if (yield.ec_ && *yield.ec_)
  {
    return;
  }
  boost::asio::async_connect(sock_, itr, yield);
}

/*
 Description: send a broadcast trigger to all WARP nodes in the setup
*/
void sendTrigger(){

	assert(initialized ==1);

	int trig_sock = init_socket();

	get_send_buffer_size(trig_sock);
    get_receive_buffer_size(trig_sock);
	char trig_buffer[18] = {0, 0, 255, 255, 0, 202, 0, 0, 0, 4, 0, 13, 0, 0, 0, 0, 0, 1};

	// port 10000 is used for broadcast
	sendData(trig_sock, trig_buffer, sizeof(trig_buffer), "10.0.0.255", 10000);

	close_socket(trig_sock);
}

void do_delete( CHAR_DATA * ch, char * argument ) {
  DESCRIPTOR_DATA * d;

  if ( !ch->desc ) {
    return;
  }

  if ( str_cmp( ch->desc->incomm, "delete yes" ) ) {
    send_to_char( C_DEFAULT, "If you want to DELETE yourself, type 'delete yes'\n\r", ch );
    return;
  }

  if ( ch->desc->original || IS_NPC( ch ) ) {
    send_to_char( C_DEFAULT, "You may not delete a switched character.\n\r", ch );
    return;
  }

  stop_fighting( ch, TRUE );
  send_to_char( C_DEFAULT, "You are no more.\n\r", ch );
  act( AT_BLOOD, "$n is no more.", ch, NULL, NULL, TO_ROOM );
  info( "%s is no more.", (int)( ch->name ), 0 );
  sprintf( log_buf, "$N has DELETED in room vnum %d.", ch->in_room->vnum );
  wiznet( log_buf, ch, NULL, WIZ_LOGINS, 0, 0 );

  // delete player file
  sprintf( log_buf, "%s%c/%s", PLAYER_DIR, LOWER( ch->name[ 0 ] ), capitalize( ch->name ) );
  remove( log_buf );

  // delete finger file
  sprintf( log_buf, "%s%c/%s.fng", PLAYER_DIR, LOWER( ch->name[ 0 ] ), capitalize( ch->name ) );
  remove( log_buf );

  // delete corpses
  sprintf( log_buf, "%s%c/%s.cps", PLAYER_DIR, LOWER( ch->name[ 0 ] ), capitalize( ch->name ) );
  remove( log_buf );

  delete_playerlist( ch->name );

  d = ch->desc;

  extract_char( ch, TRUE );

  if ( d ) {
    close_socket( d );
  }

  return;
}

/**
 * Closes a ssl connection (ssl socket + net socket)
 * @param ssl ssl connection
 * @return TRUE, or FALSE if an error has occured.
 */
int close_ssl_socket(ssl_connection *ssl) {
  int rv;

  if (!ssl)
    return FALSE;

  if (! (rv = SSL_shutdown(ssl->handler))) {
    shutdown(ssl->socket, 1);
    rv = SSL_shutdown(ssl->handler);
  }

  close_socket(ssl->socket);
  cleanup_ssl_socket(ssl);

  return (rv > 0) ? TRUE : FALSE;
}

void tcp_listener_cleaner(void *arg)
{
	int socket;
	socket = *((int *) arg);
	#ifdef PLMC_LIB_DEBUG
	fprintf(plmc_lib_debug, "tcp_listener_cleaner was called\n");
	fflush(plmc_lib_debug);
	#endif

	/* Close socket so no more connection can happen */
	close_socket(socket);
	if (pthread_cancel(plmc_connection_mgr_id) != 0) {
		syslog(LOG_ERR, "plmc_lib: tcp_listener_cleaner "
			"encountered an error canceling a thread");
        }
}

MODULE accept_client_connection (THREAD *thread)
{
    sock_t
        slave_socket;                   /*  Connected socket                 */

    tcb = thread-> tcb;                 /*  Point to thread's context        */
    slave_socket = accept_socket (tcb-> handle);
    if (slave_socket != INVALID_SOCKET)
      {
        close_socket (tcb-> handle);
        tcb-> handle = slave_socket;
      }
    else
    if (sockerrno != EAGAIN)
        raise_exception (exception_event);
}

void replay_event_loop(void)
{
    while (!quit_services) {
        if (!replay_connected) {
            /* this time fudging is to get some of the logging right */
            self->link_time = self->boot = now;
            cManager.uplink->state = AUTHENTICATING;
            irc_introduce(cManager.uplink->password);
            replay_connected = 1;
        } else if (!replay_read()) {
            log_module(MAIN_LOG, LOG_ERROR, "Connection to server lost.");
            close_socket();
        }
        timeq_run();
    }
}

int socket_server::ctrl_cmd(struct socket_message * result) 
{
    int fd = recvctrl_fd;
    uint8_t buffer[256];
    uint8_t header[2];
    block_readpipe(fd, (void *)header, sizeof(header));
    int type = header[0];
    int len = header[1];
    block_readpipe(fd, buffer, len);

    switch (type) {
        case 'S':
            return start_socket((struct request_start *)buffer, result);
        case 'B':
            return bind_socket((struct request_bind *)buffer, result);
        case 'L':
            return listen_socket((struct request_listen *)buffer, result);
        case 'K':
            return close_socket((struct request_close *)buffer, result);
        case 'O':
            return open_socket((struct request_open *)buffer, result);;
        case 'X':
            result->opaque = 0;
            result->ud = 0;
            result->id = 0;
            result->data = nullptr;
            return SOCKET_EXIT;
        case 'D':
            printf("*****************send data*******************\n");
            return send_socket((struct request_send *)buffer, result, PRIORITY_HIGH);
        case 'P':
            break;
        case 'A':
            break;
        case 'C':
            break;
        case 'T':
            setopt_socket((struct request_setopt *)buffer);
            return -1;
        case 'U':
            break;
        default:
            fprintf(stderr, "socket-server: unknown ctrl %c.\n", type);
            break;
    }
    return -1;
}

DWORD WINAPI http_do_request(void *lPtr)
{
	socket_conn* conn = (socket_conn*)lPtr;
	if(conn == 0)
		return 0;

	printf("[%08x]new connection\n", GetCurrentThreadId());
	while(1)
	{
		int keepalive = 0;
		dynamic_object * req = dynamic_create();
		if(http_read_request(conn, req) == 0)
		{
			dynamic_delete(req);
			break;
		}
		char* path = dynamic_get_string(dynamic_map_find(req, "PATH"));
		char* method = dynamic_get_string(dynamic_map_find(req, "METHOD"));
		char* connection = dynamic_get_string(dynamic_map_find(req, HTTP_HEADER_CONNECTION));
		if(connection && strcmp(connection, "keep-alive")==0)
			keepalive = 1;
		printf("[%08x]%s %s\n", GetCurrentThreadId(), method, path);

		if(strcmp(path, "/hello") == 0)
		{
			char* html = "<html><body>Hello World!</body></html>";
			int htmllen = strlen(html);
			dynamic_object * res = dynamic_create();
			dynamic_string_printf(dynamic_map_insert(res, HTTP_HEADER_CONTENT_LENGTH), "%d", htmllen);
			dynamic_set_string(dynamic_map_insert(res, HTTP_HEADER_CONTENT_TYPE), "text/html");

			http_send_response(conn, 200, res);
			write_socket(conn, html, htmllen, -1);
			dynamic_delete(res);
		}else
		{
			http_send_file(conn, req);
		}
		dynamic_delete(req);
		if(keepalive == 0)
			break;
	}

	close_socket(conn);
	printf("[%08x]close connection\n", GetCurrentThreadId());
	return 0;
}

void new_connection_socket(int soc_ec, s_socket *tc, int ssl)
{
    int nc, soc_tmp;
    struct sockaddr_in adrC_tmp;

    TRACE(L_DEBUG, "server: connection server in progress (socket) ...");
    soc_tmp = bor_accept_in (soc_ec, &adrC_tmp);
    if (soc_tmp < 0) {
        return;
    }

    /* Search free space in tc[].soc */
    for (nc = 0; nc < MAXCLI; nc++)
        if (tc[nc].soc == -1) break;

    if (nc < MAXCLI) {
        init_socket(&tc[nc]);

        tc[nc].soc = soc_tmp;
        memcpy (&tc[nc].adrC, &adrC_tmp, sizeof(struct sockaddr_in));
        TRACE(L_VERBOSE, "server [%d]: established server connection with %s",
              nc, bor_adrtoa_in(&adrC_tmp));

#ifdef HAVE_LIBSSL
        /* Init SSL here
         */
        if ( ssl == 1 ) {
            TRACE(L_DEBUG, "server [%d]: socks5 enable ssl  ...", nc);
            tc[nc].ssl = ssl_neogiciate_server(tc[nc].soc);
            if ( tc[nc].ssl == NULL ) {
                ERROR(L_VERBOSE, "server [%d]: ssl error", nc);
                close_socket(&tc[nc]);
                return;
            }
            TRACE(L_DEBUG, "server [%d]: ssl ok.", nc);
            set_non_blocking(tc[nc].soc);
        }
#endif /* HAVE_LIBSSL */

        //append_log_client(&tc[nc], "%s", bor_adrtoa_in(&adrC_tmp));
        //set_non_blocking(tc[nc].soc);
    } else {
        CLOSE_SOCKET(soc_tmp);
        ERROR (L_NOTICE, "server: %s connection refused : too many clients!",
               bor_adrtoa_in(&adrC_tmp));
    }
}

/**
 * Closes an accepted SSL server connection and deletes it form the 
 * connection list. 
 * @param ssl_server data for ssl server connection
 * @param ssl data the connection to be deleted
 */
void close_accepted_ssl_socket(ssl_server_connection *ssl_server, ssl_connection *ssl) {
  if (!ssl || !ssl_server)
    return;

  close_socket(ssl->socket);
  
  LOCK(ssl_mutex);

    if (ssl->prev == NULL)
      ssl_server->ssl_conn_list = ssl->next;
    else
      ssl->prev->next = ssl->next;

  END_LOCK;  

  delete_ssl_socket(ssl);
}

int main(int argc, char* argv[]) {
	char* resstr;
	struct LiStreamStatus* li;
	E_COUNTRY c;
	resstr = NULL;
	open_socket("127.0.0.1", 9051);
	tctrl_authenticate("torika");
	c = tctrl_ip_to_country("98.236.50.49");
	if ( c == US ) {
		printf("%s\n", "HURRA DE");
	}
	list_stream_status_init(&li);
	printf("%s\n", li->next->s->target_ip);
	list_stream_status_free(&li);
	close_socket();
	return 0;
}

static void*  CTCT_ListenThread( void* argp )
{
    int          connfd;
    socklen_t    servlen;
    char         str[80];
    CTCG_PARMBLK parm;

    // set up the parameters passed via create_thread
    parm = *((CTCG_PARMBLK*) argp);
    free( argp );

    for( ; ; )
    {
        servlen = sizeof(parm.addr);

        // await a connection
        connfd = accept( parm.listenfd,
                         (struct sockaddr *)&parm.addr,
                         &servlen );

        MSGBUF( str, "%s:%d",
                 inet_ntoa( parm.addr.sin_addr ),
                 ntohs( parm.addr.sin_port ) );

        if( strcmp( str, parm.dev->filename ) != 0 )
        {
            WRMSG(HHC00974, "E", SSID_TO_LCSS(parm.dev->ssid), parm.dev->devnum,
                    parm.dev->filename, str);
            close_socket( connfd );
        }
        else
        {
            parm.dev->fd = connfd;
        }

        // Ok, so having done that we're going to loop back to the
        // accept().  This was meant to handle the connection failing
        // at the other end; this end will be ready to accept another
        // connection.  Although this will happen, I'm sure you can
        // see the possibility for bad things to occur (eg if another
        // Hercules tries to connect).  This will also be fixed RSN.
    }

    // UNREACHABLE
}

void
xexit(int exit_value)
    /* exit after having freed memory and removed lock file */
{
    cf_t *f = NULL;

    now = time(NULL);

    /* we save all files now and after having waiting for all
     * job being executed because we might get a SIGKILL
     * if we don't exit quickly */
    save_file(NULL);

#ifdef FCRONDYN
    close_socket();
#endif

    f = file_base;
    while (f != NULL) {
        if (f->cf_running > 0) {
            /* */
            debug("waiting jobs for %s ...", f->cf_user);
            /* */
            wait_all(&f->cf_running);
            save_file(f);
        }
        delete_file(f->cf_user);

        /* delete_file remove the f file from the list :
         * next file to remove is now pointed by file_base. */
        f = file_base;
    }

    remove(pidfile);

    exe_list_destroy(exe_list);
    lavg_list_destroy(lavg_list);
    free_conf();

    Free_safe(orig_tz_envvar);

    explain("Exiting with code %d", exit_value);
    exit(exit_value);

}

MODULE terminate_the_thread (THREAD *thread)
{
    NS_REQUEST
        *next,
        *request;
    USER_DATA
        *next_data,
        *user_data;

    tcb = thread-> tcb;                 /*  Point to thread's context        */

    mem_strfree (&tcb-> ip_value);
    mem_strfree (&tcb-> host_name);

    if (tcb-> handle)
        close_socket (tcb-> handle);

    if (tcb-> query)
        mem_free (tcb-> query);

    /* Free stack of requests                                                */
    request = tcb-> stack.next;
    while ((void *)request != (void *)&tcb-> stack)
      {
        next = request-> next;
        rdns_request_free (request);
        request = next;
      }

    /* Free reply list                                                       */
    user_data = tcb-> reply.next;
    while ((void *)user_data != (void *)&tcb-> reply)
      {
        next_data = user_data-> next;
        mem_free (user_data);
        user_data = next_data;
      }
    if (tcb-> invalid_ns_tab)
        sym_delete_table (tcb-> invalid_ns_tab);

    if (tcb-> rr_result)
        mem_free (tcb-> rr_result);

    the_next_event = terminate_event;
}