bool OptionsDialog::eventFilter(QObject *object, QEvent *event)
{
    if(event->type() == QEvent::FocusOut)
    {
        if(object == ui->proxyIp)
        {
            CService addr;
            /* Check proxyIp for a valid IPv4/IPv6 address and emit the proxyIpValid signal */
            emit proxyIpValid(ui->proxyIp, LookupNumeric(ui->proxyIp->text().toStdString().c_str(), addr));
        }
    }
    return QDialog::eventFilter(object, event);
}

CService HTTPRequest::GetPeer()
{
    evhttp_connection* con = evhttp_request_get_connection(req);
    CService peer;
    if (con) {
        // evhttp retains ownership over returned address string
        const char* address = "";
        uint16_t port = 0;
        evhttp_connection_get_peer(con, (char**)&address, &port);
        peer = LookupNumeric(address, port);
    }
    return peer;
}

bool OptionsDialog::eventFilter(QObject *object, QEvent *event)
{
    if(event->type() == QEvent::FocusOut)
    {
        if(object == ui->proxyIp)
        {
            CService addr;
            
            emit proxyIpValid(ui->proxyIp, LookupNumeric(ui->proxyIp->text().toStdString().c_str(), addr));
        }
    }
    return QDialog::eventFilter(object, event);
}

bool OptionsDialog::eventFilter(QObject *object, QEvent *event)
{
	if (object == ui->proxyIp && event->type() == QEvent::FocusOut) {
		// Check proxyIP for a valid IPv4/IPv6 address
		CService addr;
		if (!LookupNumeric(ui->proxyIp->text().toStdString().c_str(), addr)) {
			ui->proxyIp->setValid(false);
			fProxyIpValid = false;
			ui->statusLabel->setStyleSheet("QLabel { color: red; }");
			ui->statusLabel->setText(tr("The supplied proxy address is invalid."));
			emit proxyIpValid(false);
		} else {
			fProxyIpValid = true;
			ui->statusLabel->clear();
			emit proxyIpValid(true);
		}
	}
	return QDialog::eventFilter(object, event);
}

void OptionsDialog::doProxyIpChecks(QValidatedLineEdit *pUiProxyIp, int nProxyPort)
{
    Q_UNUSED(nProxyPort);

    CService addrProxy;

    /* Check for a valid IPv4 / IPv6 address */
    if (!(fProxyIpsValid = LookupNumeric(pUiProxyIp->text().toStdString().c_str(), addrProxy)))
    {
        disableOkButton();
        pUiProxyIp->setValid(false);
        ui->statusLabel->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel->setText(tr("The supplied proxy address is invalid."));
    }
    else
    {
        enableOkButton();
        ui->statusLabel->clear();
    }
}

void TorController::add_onion_cb(TorControlConnection& _conn, const TorControlReply& reply)
{
    if (reply.code == 250) {
        LogPrint("tor", "tor: ADD_ONION successful\n");
        BOOST_FOREACH(const std::string &s, reply.lines) {
            std::map<std::string,std::string> m = ParseTorReplyMapping(s);
            std::map<std::string,std::string>::iterator i;
            if ((i = m.find("ServiceID")) != m.end())
                service_id = i->second;
            if ((i = m.find("PrivateKey")) != m.end())
                private_key = i->second;
        }
        service = LookupNumeric(std::string(service_id+".onion").c_str(), GetListenPort());
        LogPrintf("tor: Got service ID %s, advertising service %s\n", service_id, service.ToString());
        if (WriteBinaryFile(GetPrivateKeyFile(), private_key)) {
            LogPrint("tor", "tor: Cached service private key to %s\n", GetPrivateKeyFile());
        } else {
            LogPrintf("tor: Error writing service private key to %s\n", GetPrivateKeyFile());
        }
        AddLocal(service, LOCAL_MANUAL);
        // ... onion requested - keep connection open
    } else if (reply.code == 510) { // 510 Unrecognized command

bool static TestParse(std::string src, std::string canon)
{
    CService addr(LookupNumeric(src.c_str(), 65535));
    return canon == addr.ToString();
}

int main(int argc, char **argv) {
    signal(SIGPIPE, SIG_IGN);
    setbuf(stdout, nullptr);
    CDnsSeedOpts opts;
    opts.ParseCommandLine(argc, argv);
    printf("Supporting whitelisted filters: ");
    for (std::set<uint64_t>::const_iterator it = opts.filter_whitelist.begin();
         it != opts.filter_whitelist.end(); it++) {
        if (it != opts.filter_whitelist.begin()) {
            printf(",");
        }
        printf("0x%lx", (unsigned long)*it);
    }
    printf("\n");
    if (opts.tor) {
        CService service(LookupNumeric(opts.tor, 9050));
        if (service.IsValid()) {
            printf("Using Tor proxy at %s\n", service.ToStringIPPort().c_str());
            SetProxy(NET_TOR, service);
        }
    }
    if (opts.ipv4_proxy) {
        CService service(LookupNumeric(opts.ipv4_proxy, 9050));
        if (service.IsValid()) {
            printf("Using IPv4 proxy at %s\n",
                   service.ToStringIPPort().c_str());
            SetProxy(NET_IPV4, service);
        }
    }
    if (opts.ipv6_proxy) {
        CService service(LookupNumeric(opts.ipv6_proxy, 9050));
        if (service.IsValid()) {
            printf("Using IPv6 proxy at %s\n",
                   service.ToStringIPPort().c_str());
            SetProxy(NET_IPV6, service);
        }
    }
    bool fDNS = true;
    if (opts.fUseTestNet) {
        printf("Using testnet.\n");
        netMagic[0] = 0xf4;
        netMagic[1] = 0xe5;
        netMagic[2] = 0xf3;
        netMagic[3] = 0xf4;
        seeds = testnet_seeds;
        fTestNet = true;
    }
    if (!opts.ns) {
        printf("No nameserver set. Not starting DNS server.\n");
        fDNS = false;
    }
    if (fDNS && !opts.host) {
        fprintf(stderr, "No hostname set. Please use -h.\n");
        exit(1);
    }
    if (fDNS && !opts.mbox) {
        fprintf(stderr, "No e-mail address set. Please use -m.\n");
        exit(1);
    }
    FILE *f = fopen("dnsseed.dat", "r");
    if (f) {
        printf("Loading dnsseed.dat...");
        CAutoFile cf(f, SER_DISK, CLIENT_VERSION);
        cf >> db;
        if (opts.fWipeBan) db.banned.clear();
        if (opts.fWipeIgnore) db.ResetIgnores();
        printf("done\n");
    }
    pthread_t threadDns, threadSeed, threadDump, threadStats;
    if (fDNS) {
        printf("Starting %i DNS threads for %s on %s (port %i)...",
               opts.nDnsThreads, opts.host, opts.ns, opts.nPort);
        dnsThread.clear();
        for (int i = 0; i < opts.nDnsThreads; i++) {
            dnsThread.push_back(new CDnsThread(&opts, i));
            pthread_create(&threadDns, nullptr, ThreadDNS, dnsThread[i]);
            printf(".");
            Sleep(20);
        }
        printf("done\n");
    }
    printf("Starting seeder...");
    pthread_create(&threadSeed, nullptr, ThreadSeeder, nullptr);
    printf("done\n");
    printf("Starting %i crawler threads...", opts.nThreads);
    pthread_attr_t attr_crawler;
    pthread_attr_init(&attr_crawler);
    pthread_attr_setstacksize(&attr_crawler, 0x20000);
    for (int i = 0; i < opts.nThreads; i++) {
        pthread_t thread;
        pthread_create(&thread, &attr_crawler, ThreadCrawler, &opts.nThreads);
    }
    pthread_attr_destroy(&attr_crawler);
    printf("done\n");
    pthread_create(&threadStats, nullptr, ThreadStats, nullptr);
    pthread_create(&threadDump, nullptr, ThreadDumper, nullptr);
    void *res;
    pthread_join(threadDump, &res);
    return 0;
}