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);
}

/**
 * close the SACD device and clean up.
 */
static int sacd_net_input_close(sacd_input_t dev)
{
    if (!dev)
    {
        return 0;
    }
    else
    {
        ServerRequest request;
        ServerResponse response;
        pb_istream_t input = pb_istream_from_socket(&dev->fd);
        pb_ostream_t output = pb_ostream_from_socket(&dev->fd);
        uint8_t zero = 0;

        request.type = ServerRequest_Type_DISC_CLOSE;
        if (!pb_encode(&output, ServerRequest_fields, &request))
        {
            goto error;
        }

        pb_write(&output, &zero, 1);

        if (!pb_decode(&input, ServerResponse_fields, &response))
        {
            goto error;
        }

        if (response.result == 0 || response.type != ServerResponse_Type_DISC_CLOSED)
        {
            goto error;
        }
    }

error:

    if(dev)
    {
        socket_destroy(&dev->fd);
        socket_close();
        if (dev->input_buffer)
        {
            free(dev->input_buffer);
            dev->input_buffer = 0;
        }
        free(dev);
        dev = 0;
    }
    return 0;
}

static int global_connect(lua_State *L) {
    const char *remoteaddr = luaL_checkstring(L, 1);
    const char *remoteserv = luaL_checkstring(L, 2);
    const char *localaddr  = luaL_optstring(L, 3, NULL);
    const char *localserv  = luaL_optstring(L, 4, "0");
    int family = inet_optfamily(L, 5, "unspec");
    p_tcp tcp = (p_tcp) lua_newuserdata(L, sizeof(t_tcp));
    struct addrinfo bindhints, connecthints;
    const char *err = NULL;
    /* initialize tcp structure */
    memset(tcp, 0, sizeof(t_tcp));
    io_init(&tcp->io, (p_send) socket_send, (p_recv) socket_recv,
            (p_error) socket_ioerror, &tcp->sock);
    timeout_init(&tcp->tm, -1, -1);
    buffer_init(&tcp->buf, &tcp->io, &tcp->tm);
    tcp->sock = SOCKET_INVALID;
    tcp->family = AF_UNSPEC;
    /* allow user to pick local address and port */
    memset(&bindhints, 0, sizeof(bindhints));
    bindhints.ai_socktype = SOCK_STREAM;
    bindhints.ai_family = family;
    bindhints.ai_flags = AI_PASSIVE;
    if (localaddr) {
        err = inet_trybind(&tcp->sock, &tcp->family, localaddr,
            localserv, &bindhints);
        if (err) {
            lua_pushnil(L);
            lua_pushstring(L, err);
            return 2;
        }
    }
    /* try to connect to remote address and port */
    memset(&connecthints, 0, sizeof(connecthints));
    connecthints.ai_socktype = SOCK_STREAM;
    /* make sure we try to connect only to the same family */
    connecthints.ai_family = tcp->family;
    err = inet_tryconnect(&tcp->sock, &tcp->family, remoteaddr, remoteserv,
         &tcp->tm, &connecthints);
    if (err) {
        socket_destroy(&tcp->sock);
        lua_pushnil(L);
        lua_pushstring(L, err);
        return 2;
    }
    auxiliar_setclass(L, "tcp{client}", -1);
    return 1;
}

/*-------------------------------------------------------------------------*\
* Tries to connect to remote address (address, port)
\*-------------------------------------------------------------------------*/
const char *inet_tryconnect(p_socket ps, int *family, const char *address,
        const char *serv, p_timeout tm, struct addrinfo *connecthints)
{
#ifdef LUASOCKET_SECURITY_SANDBOX
    if (luasocket_ip_allowed(address))
        return "connect restricted";
#endif // LUASOCKET_SECURITY_SANDBOX
    struct addrinfo *iterator = NULL, *resolved = NULL;
    const char *err = NULL;
    int current_family = *family;
    /* try resolving */
    err = socket_gaistrerror(getaddrinfo(address, serv,
                connecthints, &resolved));
    if (err != NULL) {
        if (resolved) freeaddrinfo(resolved);
        return err;
    }
    for (iterator = resolved; iterator; iterator = iterator->ai_next) {
        timeout_markstart(tm);
        /* create new socket if necessary. if there was no
         * bind, we need to create one for every new family
         * that shows up while iterating. if there was a
         * bind, all families will be the same and we will
         * not enter this branch. */
        if (current_family != iterator->ai_family || *ps == SOCKET_INVALID) {
            socket_destroy(ps);
            err = inet_trycreate(ps, iterator->ai_family,
                iterator->ai_socktype, iterator->ai_protocol);
            if (err) continue;
            current_family = iterator->ai_family;
            /* set non-blocking before connect */
            socket_setnonblocking(ps);
        }
        /* try connecting to remote address */
        err = socket_strerror(socket_connect(ps, (SA *) iterator->ai_addr,
            (socklen_t) iterator->ai_addrlen, tm));
        /* if success or timeout is zero, break out of loop */
        if (err == NULL || timeout_iszero(tm)) {
            *family = current_family;
            break;
        }
    }
    freeaddrinfo(resolved);
    /* here, if err is set, we failed */
    return err;
}

void _socket_accept_loop(void* ctx) {
    
    struct socket_t* s = (struct socket_t*)ctx;
   
    mutex_lock(s->mutex);
    _socket_set_loop_name(s, "Accept Loop");
    
    s->is_connected = true;
    
    int new_socket_fd = 0;
    do {
        
        struct sockaddr_storage client_addr;
        socklen_t addr_len = sizeof(client_addr);
        mutex_unlock(s->mutex);
        new_socket_fd = accept(s->socket, (struct sockaddr*)&client_addr, &addr_len);
        mutex_lock(s->mutex);
        
        if (new_socket_fd >= 0) {
            
            struct socket_t* new_socket = (struct socket_t*)malloc(sizeof(struct socket_t));
            bzero(new_socket, sizeof(struct socket_t));
            
            new_socket->socket = new_socket_fd;
            new_socket->mutex = mutex_create();
            new_socket->is_connected = true;
            
            bool accept = false;
            if (s->callbacks.accept != NULL) {
                mutex_unlock(s->mutex);
                accept = s->callbacks.accept(s, new_socket, s->callbacks.ctx.accept);
                mutex_lock(s->mutex);
            }
            
            if (!accept)
                socket_destroy(new_socket);
            
        }
        
    } while (new_socket_fd >= 0);
    mutex_unlock(s->mutex);
    
    socket_close(s);
    
}

static void tcp_sock_close(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
	int socket_id;
	socket_core_t *sock_core;
	tcp_sockdata_t *socket;
	tcp_error_t trc;
	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 = (tcp_sockdata_t *)sock_core->specific_data;
	fibril_mutex_lock(&socket->lock);

	if (socket->conn != NULL) {
		trc = tcp_uc_close(socket->conn);
		if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
			fibril_mutex_unlock(&socket->lock);
			async_answer_0(callid, EBADF);
			return;
		}
	}

	/* Grab recv_buffer_lock because of CV wait in tcp_sock_recv_fibril() */
	fibril_mutex_lock(&socket->recv_buffer_lock);
	socket->sock_core = NULL;
	fibril_mutex_unlock(&socket->recv_buffer_lock);

	rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
	    tcp_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);
}