C++ socket_destroy函数代码示例

void web_server_stop(struct web_server_t* ws) {

    mutex_lock(ws->mutex);

    if (ws->is_running) {

        ws->is_running = false;

        if (ws->socket_ipv4 != NULL) {
            socket_destroy(ws->socket_ipv4);
            ws->socket_ipv4 = NULL;
        }
        if (ws->socket_ipv6 != NULL) {
            socket_destroy(ws->socket_ipv6);
            ws->socket_ipv6 = NULL;
        }

        while (ws->connection_count > 0) {
            mutex_unlock(ws->mutex);
            socket_destroy(ws->connections[0].socket);
            web_server_connection_destroy(ws->connections[0].web_connection);
            mutex_lock(ws->mutex);
        }

        log_message(LOG_INFO, "Server stopped");

    } else
        log_message(LOG_ERROR, "Cannot stop: Server is not running");

    mutex_unlock(ws->mutex);

}

static GSOCKET socket_create(int port)
{
    GSOCKET sock;
    
#ifdef WIN32
    {
	/* WinSockの初期化 */
	int		nResult;
	WORD	wRequireVersion;	/* 使用するWinSockのバージョン */
	WSADATA	lpWSAData;		/* WinSock初期化の結果 */
    
	/* WinSock2を使用するWinSockのバージョンとして設定 */
	wRequireVersion = MAKEWORD( 2, 0 );

	/* WinSockの初期化を行なう */
	nResult = WSAStartup( wRequireVersion, &lpWSAData );
	if( nResult != 0  )
	{
	    ErrMsg("WinSock initialize failed: %d\n", nResult);
	    return NULL;
	}

	/* 初期化したWinSockのバージョンが要求したものか確認 */
	if( lpWSAData.wVersion != wRequireVersion )
	{
	    ErrMsg("WinSock version mismatch: %d\n", nResult);
	    return NULL;
	}
    }
#endif

    sock = (GSOCKET)malloc(sizeof(struct _GSOCKET));
    if ((sock->fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
	free(sock);
	return NULL;
    }
    
    memset((char *)&sock->addr, 0, sizeof(sock->addr));
    sock->child_fd = -1;

    sock->addr.sin_family = AF_INET;
    sock->addr.sin_addr.s_addr = INADDR_ANY;
    sock->addr.sin_port = htons( (unsigned short) port);
    
    if (bind(sock->fd, (struct sockaddr *)&sock->addr, sizeof(sock->addr)) == -1
	|| listen(sock->fd, 1) == -1) {
	socket_destroy(sock);
	return NULL;
    }
    
#if defined(_WIN32) && !defined(__CYGWIN32__)
    {
	u_long ulCmdArg;
	ulCmdArg = 1;
	ioctlsocket(sock->fd, FIONBIO, &ulCmdArg);
    }
#endif

    return sock;
}

/*-------------------------------------------------------------------------*\
* Closes socket used by object 
\*-------------------------------------------------------------------------*/
static int meth_close(lua_State *L)
{
    p_unix un = (p_unix) auxiliar_checkgroup(L, "unix{any}", 1);
    socket_destroy(&un->sock);
    lua_pushnumber(L, 1);
    return 1;
}

void _rtp_socket_socket_closed_callback(socket_p socket, void* ctx) {
    
    struct rtp_socket_t* rs = (struct rtp_socket_t*)ctx;
    
    mutex_lock(rs->mutex);
    
    for (uint32_t i = 0 ; i < rs->sockets_count ; i++)
        if (rs->sockets[i]->socket == socket) {
            
            socket_destroy(rs->sockets[i]->socket);
            
            free(rs->sockets[i]);
            
            for (uint32_t a = i + 1 ; a < rs->sockets_count ; a++)
                rs->sockets[a - 1] = rs->sockets[a];
            
            rs->sockets_count--;
            
            break;
            
        }
    
    mutex_unlock(rs->mutex);
    
}

void network_exit(void) {
	log_debug("Shutting down network subsystem");

	array_destroy(&_clients, (ItemDestroyFunction)client_destroy); // might call network_create_zombie
	array_destroy(&_zombies, (ItemDestroyFunction)zombie_destroy);

	if (_plain_server_socket_open) {
		event_remove_source(_plain_server_socket.base.handle, EVENT_SOURCE_TYPE_GENERIC);
		socket_destroy(&_plain_server_socket);
	}

	if (_websocket_server_socket_open) {
		event_remove_source(_websocket_server_socket.base.handle, EVENT_SOURCE_TYPE_GENERIC);
		socket_destroy(&_websocket_server_socket);
	}
}

/**
 * Close the connection before the GC collect the object.
 */
static int meth_destroy(lua_State *L)
{
  p_ssl ssl = (p_ssl)luaL_checkudata(L, 1, "SSL:Connection");
  if (ssl->state == LSEC_STATE_CONNECTED) {
    socket_setblocking(&ssl->sock);
    SSL_shutdown(ssl->ssl);
  }
  if (ssl->sock != SOCKET_INVALID) {
    socket_destroy(&ssl->sock);
  }
  ssl->state = LSEC_STATE_CLOSED;
  if (ssl->ssl) {
    /* Clear the registries */
    luaL_getmetatable(L, "SSL:Verify:Registry");
    lua_pushlightuserdata(L, (void*)ssl->ssl);
    lua_pushnil(L);
    lua_settable(L, -3);
    luaL_getmetatable(L, "SSL:SNI:Registry");
    lua_pushlightuserdata(L, (void*)ssl->ssl);
    lua_pushnil(L);
    lua_settable(L, -3);
    /* Destroy the object */
    SSL_free(ssl->ssl);
    ssl->ssl = NULL;
  }
  return 0;
}

static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
	int socket_id;
	socket_core_t *sock_core;
	udp_sockdata_t *socket;
	int rc;

	log_msg(LVL_DEBUG, "tcp_sock_close()");
	socket_id = SOCKET_GET_SOCKET_ID(call);

	sock_core = socket_cores_find(&client->sockets, socket_id);
	if (sock_core == NULL) {
		async_answer_0(callid, ENOTSOCK);
		return;
	}

	socket = (udp_sockdata_t *)sock_core->specific_data;
	fibril_mutex_lock(&socket->lock);

	rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
	    udp_free_sock_data);
	if (rc != EOK) {
		fibril_mutex_unlock(&socket->lock);
		async_answer_0(callid, rc);
		return;
	}

	fibril_mutex_unlock(&socket->lock);
	async_answer_0(callid, EOK);
}

/*-------------------------------------------------------------------------*\
* Closes socket used by object 
\*-------------------------------------------------------------------------*/
static int meth_close(lua_State *L)
{
    p_tcp tcp = (p_tcp) auxiliar_checkgroup(L, "tcp{any}", 1);
    socket_destroy(&tcp->sock);
    lua_pushnumber(L, 1);
    return 1;
}

void server_destroy ( void )
{
    if (g_sock != NULL) {
	socket_destroy(g_sock);
	g_sock = NULL;
    }
    
    return;
}

bool rtp_socket_setup(struct rtp_socket_t* rs, struct sockaddr* local_end_point) {
    
    socket_p udp_socket = socket_create("RTP UDP Socket", true);
    socket_p tcp_socket = socket_create("RTP TCP Listen Socket", false);
    
    if (socket_bind(udp_socket, local_end_point) && socket_bind(tcp_socket, local_end_point)) {
        _rtp_socket_add_socket(rs, udp_socket, true);
        socket_set_receive_callback(udp_socket, _rtp_socket_socket_receive_callback, rs);
        _rtp_socket_add_socket(rs, tcp_socket, false);
        socket_set_accept_callback(tcp_socket, _rtp_socket_accept_callback, rs);
        return true;
    }
    
    socket_destroy(udp_socket);
    socket_destroy(tcp_socket);
    
    return false;
    
}

int server_init ( int port )
{
    if (g_sock != NULL) socket_destroy(g_sock);
    
    if ((g_sock = socket_create(port)) == NULL) {
	return -1;
    }

    return 1;
}

void client_destroy(Client *client) {
	event_remove_source(client->socket, EVENT_SOURCE_TYPE_GENERIC);
	socket_destroy(client->socket);

	if (client->peer != _unknown_peer_name) {
		free(client->peer);
	}

	array_destroy(&client->pending_requests, NULL);
}

bool web_server_start(struct web_server_t* ws, uint16_t port) {

    mutex_lock(ws->mutex);

    if (!ws->is_running) {

        log_message(LOG_INFO, "Trying port %d", port);

        ws->socket_ipv4 = _web_server_bind(ws, port, sockaddr_type_inet_4);
        ws->socket_ipv6 = _web_server_bind(ws, port, sockaddr_type_inet_6);

        if (((ws->socket_types & sockaddr_type_inet_4) == 0 || ws->socket_ipv4 != NULL) && ((ws->socket_types & sockaddr_type_inet_6) == 0 || ws->socket_ipv6 != NULL)) {

            if ((ws->socket_types & sockaddr_type_inet_4) != 0)
                socket_set_accept_callback(ws->socket_ipv4, _web_server_socket_accept_callback, ws);
            if ((ws->socket_types & sockaddr_type_inet_6) != 0)
                socket_set_accept_callback(ws->socket_ipv6, _web_server_socket_accept_callback, ws);

            ws->is_running = true;

            mutex_unlock(ws->mutex);

            return true;

        }

        if (ws->socket_ipv4 != NULL)
            socket_destroy(ws->socket_ipv4);
        if (ws->socket_ipv6 != NULL)
            socket_destroy(ws->socket_ipv6);

        log_message(LOG_INFO, "Server started.");

    } else
        log_message(LOG_ERROR, "Cannot start: Server is already running");

    mutex_unlock(ws->mutex);

    return false;

}

/**
 * Close the connection before the GC collect the object.
 */
static int meth_destroy(lua_State *L)
{
  p_ssl ssl = (p_ssl) lua_touserdata(L, 1);
  if (ssl->ssl) {
    socket_setblocking(&ssl->sock);
    SSL_shutdown(ssl->ssl);
    socket_destroy(&ssl->sock);
    SSL_free(ssl->ssl);
    ssl->ssl = NULL;
  }
  return 0;
}

void mesh_exit(void) {
    log_info("Shutting down mesh subsystem");

    // Cleanup mesh listen socket.
    if (is_mesh_listen_socket_open) {
        event_remove_source(mesh_listen_socket.base.handle,
                            EVENT_SOURCE_TYPE_GENERIC);

        socket_destroy(&mesh_listen_socket);
    }

    // Mesh stack related cleanup is done in mesh_stack_destroy().
    array_destroy(&mesh_stacks, (ItemDestroyFunction)mesh_stack_destroy);
}