void NetworkManager::run()
{
    if ( resolving && ! resolver_busy ) // finished resolv
    {
        resolving = false;
        bool found_wanted = false;
        for ( std::list<Address>::iterator i = rqueue.begin(); i != rqueue.end(); i++ )
        {
            if ( thread_work.compareDest(*i) )
            {
                (*i) = thread_work;
                found_wanted = true;
                break;
            }
        }

        --to_resolve;
        resolving = false;

        if ( ! found_wanted )
        {
            LOGGER.warning("Resolved something unwanted");
        }
    }

    if ( to_resolve > 0 && ! resolving )
    {
        bool found_waiting = false;
        for ( std::list<Address>::iterator i = rqueue.begin(); i != rqueue.end(); i++ )
        {
            if ( (*i).status == Address::ST_WAITING )
            {
                (*i).status = Address::ST_RESOLVING;
                thread_work = (*i);
                found_waiting = true;
                break;
            }
        }

        resolver_busy = true;
        resolving = true;
        SDL_SemPost(semaphore);

        if ( ! found_waiting )
        {
            LOGGER.warning("to_resolve has something but there is no waiting here");
        }
    }

    SocketManager::handleEvents();
}
int NetworkManager::queryAddress(Address &address)
{
    struct addrinfo hints;
    struct addrinfo *firstaddress = 0;

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = address.socktype;
    hints.ai_protocol = address.protocol;
    if ( address.forBinding )
    {
        hints.ai_flags = AI_PASSIVE;
    }

    hints.ai_flags |= AI_NUMERICHOST|AI_NUMERICSERV;

    int res = getaddrinfo(address.str_host.size() > 0 ? address.str_host.c_str() : 0,
                          address.str_port.c_str(),
                          &hints, &firstaddress);
    if ( res )
    {
        freeaddrinfo(firstaddress);

        for ( std::list<Address>::iterator i = rqueue.begin(); i != rqueue.end(); i++ )
        {
            if ( address.compareDest(*i) )
            {
                switch ( (*i).status )
                {
                    case Address::ST_OK :
                        address.ss_len = (*i).ss_len;
                        memcpy(&address.ss, &(*i).ss, (*i).ss_len);
                        // fall through

                    case Address::ST_ERROR :
                        address.status = (*i).status;
                        rqueue.erase(i);
                        break;

                    default:
                        address.status = (*i).status;

                }

                return address.status;
            }
        }
        address.status = Address::ST_WAITING;
        rqueue.push_back(address);
        ++to_resolve;
    }
    else
    {
        address.ss_len = firstaddress->ai_addrlen;
        memcpy(&address.ss, firstaddress->ai_addr, firstaddress->ai_addrlen);
        freeaddrinfo(firstaddress);

        address.status = Address::ST_OK;
    }

    return address.status;
}