static void* _at_tcp_server(void *args)
{
    assert(args);

    ATDataHandler *handler = (ATDataHandler*)args;
    at_conn_tcp_t *hdl = (at_conn_tcp_t*)handler->iface_args;
    conn_tcp_t clients[TCP_CLIENTS_PER_SERVER];
    conn_tcp_t *c;

    /* handle the client connections */
    at_conn_tcp_client_t holders[TCP_CLIENTS_PER_SERVER];
    at_conn_tcp_client_t *free_clients = NULL;
    at_conn_tcp_client_t *used_clients = NULL;
    for (int idx = 0; idx < TCP_CLIENTS_PER_SERVER; ++idx)
        LL_PREPEND(free_clients, holders + idx);

    /* create a listening TCP socket */
    conn_tcp_create(&hdl->tcp_conn, NULL, sizeof(ipv6_addr_t), AF_INET6, handler->src_port);
    conn_tcp_listen(&hdl->tcp_conn, clients, TCP_CLIENTS_PER_SERVER);

    DEBUG("_at_tcp_server(): returned from TCP listen\n");

    /* try accepting new TCP clients */
    int ret;
    msg_t m;
    while (msg_receive(&m) > 0)
    {
        DEBUG("_at_tcp_server(): received a new message\n");

        switch (m.type)
        {
        // TODO export this define so you can make a parent thread which
        case GNRC_NETAPI_MSG_TYPE_ACK + 5:
            /* accept a new client if we have to */
            ret = conn_tcp_accept(&hdl->tcp_conn, &c);

            if (ret == -EAGAIN) {
                /* no new clients are waiting nothing to do here */
            } else if (ret == 0) {
                DEBUG("_at_tcp_server(): received new connection\n");

                /* create a new client handler object */
                at_conn_tcp_client_t *client = free_clients;

                /* create a new data handler object */
                client->tcp_conn = c;
                client->identifier = TCP_CLIENT_IDENTIFIER;
                client->handler = ATAllocDataHandler(handler->src_port, c->peer_port, (ipv6_addr_t*)c->peer_addr, false, &_at_tcp_interface, client);
                assert(client->handler); // TODO close the client connection without  saying anything

                /* move to the used list */
                LL_DELETE(free_clients, client);
                LL_PREPEND(used_clients, client);

                /* TODO inform the host that a new connection is available */
                ATResponse resp = ATRegisterDataHandler(client->handler);
                assert(resp == OK);

            } else {
                switch (ret) {
                case -EOPNOTSUPP:
                    DEBUG("conn_tcp_accept() : -EOPNOTSUPP : Operation not supported on active Connection\n");
                    //return NULL;

                default:
                    DEBUG("conn_tcp_accept() : %d : Unexpected return value: Go fix it!\n", ret);
                    //return NULL;
                }
            }

            /* reserve a base packet to store the data */
            gnrc_pktsnip_t *snip = gnrc_pktbuf_add(NULL, NULL, TCP_MAX_PACKET_SIZE, GNRC_NETTYPE_UNDEF);
            if (!snip)
                DEBUG("_at_tcp_server(): no packet buffer allocated");

            /* check if any data is received on the client connections */
            at_conn_tcp_client_t *cli, *tmp;
            LL_FOREACH_SAFE(used_clients, cli, tmp)
            {
                /* try to read data from the connection */
                int read;
                while ((read = conn_tcp_recv(cli->tcp_conn, snip->data, TCP_MAX_PACKET_SIZE)) > 0) {
                    /* we have read data, create a new data interrupt */
                    if (read < TCP_MAX_PACKET_SIZE)
                        gnrc_pktbuf_realloc_data(snip, read);

                    /* queue the incomming packet in the data buffer */
                    DEBUG("_at_tcp_server(): received packet containing %d bytes\n", read);
                    if (!ATReceivedPacket(snip, &_at_tcp_interface, &cli->handler->addr, cli->handler->dst_port, cli->handler->src_port))
                        assert(false);

                    /* create a new packet snippet */
                    snip = gnrc_pktbuf_add(NULL, NULL, TCP_MAX_PACKET_SIZE, GNRC_NETTYPE_UNDEF);
                }

                /* check if the connection has closed */
                DEBUG("_at_tcp_server(): read has returned with: %d\n", read);
                if (read == 0 && cli->tcp_conn->state == CLOSE_WAIT)
                {
                    /* TODO notify the host */

                    /* free the data handler */
                    ATFreeDataHandler(cli->handler);

                    /* the connection has closed, we must free it */
                    LL_DELETE(used_clients, cli);
                    LL_PREPEND(free_clients, cli);
                }
            }

            /* free the temporary buffer */
            gnrc_pktbuf_release(snip);
            break;

        case TCP_MSG_CLOSE:
            // TODO close all clients

            // close the server socket
            ret = conn_tcp_close(&hdl->tcp_conn);
            switch (ret) {
                case 0:
                    DEBUG("conn_tcp_close() : 0 : ok\n");
                    break;

                default:
                    DEBUG("conn_tcp_close() : %d : Unexpected return value: Go fix it!\n", ret);
            }
            break;

        case TCP_MSG_QUIT_THREAD:
            // TODO do actions of: TCP_MSG_CLOSE

            // TODO close the thread
            break;
        }
    }

    return NULL;
}

static void* _at_tcp_client(void *args)
{
    assert(args);

    ATDataHandler *handler = (ATDataHandler*)args;
    at_conn_tcp_t *hdl = (at_conn_tcp_t*)handler->iface_args;

    /* create a listening TCP socket */
    conn_tcp_create(&hdl->tcp_conn, NULL, sizeof(ipv6_addr_t), AF_INET6, handler->src_port);
    int ret = conn_tcp_connect(&hdl->tcp_conn, &handler->addr, sizeof(ipv6_addr_t), handler->dst_port);

    DEBUG("_at_tcp_client(): returned from TCP connect: %d\n", ret);

    /* try accepting new TCP clients */
    msg_t m;
    while (msg_receive(&m) > 0)
    {
        DEBUG("_at_tcp_client(): received a new message\n");

        switch (m.type)
        {
        // TODO export this define so you can make a parent thread which
        case GNRC_NETAPI_MSG_TYPE_ACK + 5:
        {
            /* reserve a base packet to store the data */
            gnrc_pktsnip_t *snip = gnrc_pktbuf_add(NULL, NULL, TCP_MAX_PACKET_SIZE, GNRC_NETTYPE_UNDEF);
            if (!snip)
                DEBUG("_at_tcp_client(): no packet buffer allocated");

            /* try to read data from the connection */
            int read;
            while ((read = conn_tcp_recv(&hdl->tcp_conn, snip->data, TCP_MAX_PACKET_SIZE)) > 0) {
                /* we have read data, create a new data interrupt */
                if (read < TCP_MAX_PACKET_SIZE)
                    gnrc_pktbuf_realloc_data(snip, read);

                /* queue the incomming packet in the data buffer */
                DEBUG("_at_tcp_client(): received packet containing %d bytes\n", read);
                if (!ATReceivedPacket(snip, &_at_tcp_interface, &handler->addr, handler->dst_port, handler->src_port))
                    assert(false);

                /* create a new packet snippet */
                snip = gnrc_pktbuf_add(NULL, NULL, TCP_MAX_PACKET_SIZE, GNRC_NETTYPE_UNDEF);
            }

            /* check if the connection has closed */
            DEBUG("_at_tcp_client(): read has returned with: %d\n", read);
            if (read == 0 && hdl->tcp_conn.state == CLOSE_WAIT)
            {
                /* TODO notify the host */

                /* free the data handler */
                ATFreeDataHandler(handler);
            }

            /* free the temporary buffer */
            gnrc_pktbuf_release(snip);
        } break;

        case TCP_MSG_CLOSE:
        {
            // TODO close all clients

            // close the server socket
            ret = conn_tcp_close(&hdl->tcp_conn);
            switch (ret) {
                case 0:
                    DEBUG("conn_tcp_close() : 0 : ok\n");
                    break;

                default:
                    DEBUG("conn_tcp_close() : %d : Unexpected return value: Go fix it!\n", ret);
                    break;
            }
        } break;

        case TCP_MSG_QUIT_THREAD:
        {
            // TODO do actions of: TCP_MSG_CLOSE

            // TODO close the thread
        } break;
        }
    }

    return NULL;
}

/**
 * Send the UDP packet and return to command mode
 */
static ATResponse _at_tcp_finished_write(ATDataHandler *handler, size_t len)
{
    assert(handler);
    assert(handler->iface_args);

    /* if no data in the buffer just free it */
    if (!len) {
        gnrc_pktbuf_release(handler->output);
        return OK;
    }

    /* resize the TCP pay-load */
    if (gnrc_pktbuf_realloc_data(handler->output, len) != 0) {
        gnrc_pktbuf_release(handler->output);
        return ATSetErrorMessage(ErrorInternal, "unable to reallocate the TCP header");
    }

    data = (uint8_t*)handler->output->data;

    /* send data to the given TCP connection */
    int res = 0;
    uint8_t *data;
    uint32_t ident = *(uint32_t*)handler->iface_args;
    for (int idx = 0; idx < len; idx += res)
    {
        /* find the object that is stored in the interface arguments */
        if (ident == TCP_MAIN_IDENTIFIER) {
            /* we use a main TCP object created by the AT command set */
            at_conn_tcp_t *hdl = (at_conn_tcp_t*)handler->iface_args;
            res = conn_tcp_send(&hdl->tcp_conn, data + res, len - res);
        } else if (ident == TCP_CLIENT_IDENTIFIER) {
            /* we use a TCP client object create by a TCP server */
            at_conn_tcp_client_t *hdl = (at_conn_tcp_client_t*)handler->iface_args;
            res = conn_tcp_send(hdl->tcp_conn, data + res, len - res);
        }
    }

    return OK;
}

/**
 * Unregister the UDP listening connection
 */
static ATResponse _at_tcp_conn_close(ATDataHandler *handler)
{
    assert(handler);
    assert(handler->iface_args);

    /* close the connection */
    int ret = -1234567;
    uint32_t identity = *(uint32_t*)handler->iface_args;
    if (identity == TCP_MAIN_IDENTIFIER) {
        at_conn_tcp_t *hdl = (at_conn_tcp_t*)handler->iface_args;
        ret = conn_tcp_close(&hdl->tcp_conn);
    } else if (identity == TCP_CLIENT_IDENTIFIER) {
        at_conn_tcp_client_t *hdl = (at_conn_tcp_client_t*)handler->iface_args;
        ret = conn_tcp_close(hdl->tcp_conn);

        /* TODO how to free the client object in the server ? Does this happen automatically due to the messages ? */
    }

    return OK;
}