bump snap version

Merge pull request #32 from Snawoot/fallback
feat: Hola API communication failover
2026-04-04 22:18:17 +00:00 · 2021-03-15 04:13:04 +02:00 · 2021-03-15 04:12:15 +02:00 · 2021-03-15 04:07:03 +02:00 · 2021-03-15 02:21:23 +02:00 · 2021-03-15 02:13:42 +02:00
20 changed files with 1792 additions and 750 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1 @@
+bin/
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,7 @@
 # Dependency directories (remove the comment below to include it)
 # vendor/
 bin/
+*.snap
+
+# hola-proxy binary
+hola-proxy
--- a/19
+++ b/19
@@ -0,0 +1,19 @@
+FROM golang AS build
+
+ARG GIT_DESC=undefined
+
+WORKDIR /go/src/github.com/Snawoot/hola-proxy
+COPY . .
+RUN CGO_ENABLED=0 go build -a -tags netgo -ldflags '-s -w -extldflags "-static" -X main.version='"$GIT_DESC"
+ADD https://curl.haxx.se/ca/cacert.pem /certs.crt
+RUN chmod 0644 /certs.crt
+
+FROM scratch AS arrange
+COPY --from=build /go/src/github.com/Snawoot/hola-proxy/hola-proxy /
+COPY --from=build /certs.crt /etc/ssl/certs/ca-certificates.crt
+
+FROM scratch
+COPY --from=arrange / /
+USER 9999:9999
+EXPOSE 8080/tcp
+ENTRYPOINT ["/hola-proxy", "-bind-address", "0.0.0.0:8080"]
--- a/24
+++ b/24
@@ -1,7 +1,8 @@
 PROGNAME = hola-proxy
 OUTSUFFIX = bin/$(PROGNAME)
+VERSION := $(shell git describe)
 BUILDOPTS = -a -tags netgo
-LDFLAGS = -ldflags '-s -w -extldflags "-static"'
+LDFLAGS = -ldflags '-s -w -extldflags "-static" -X main.version=$(VERSION)'

 src = $(wildcard *.go)

@@ -54,3 +55,24 @@ $(OUTSUFFIX).windows-386.exe: $(src)

 clean:
 	rm -f bin/*
+
+fmt:
+	go fmt ./...
+
+run:
+	go run $(LDFLAGS) .
+
+install:
+	go install $(BUILDOPTS) $(LDFLAGS) .
+
+.PHONY: clean all native fmt install \
+	bin-native \
+	bin-linux-amd64 \
+	bin-linux-386 \
+	bin-linux-arm \
+	bin-freebsd-amd64 \
+	bin-freebsd-386 \
+	bin-freebsd-arm \
+	bin-darwin-amd64 \
+	bin-windows-amd64 \
+	bin-windows-386
--- a/README.md
+++ b/README.md
@@ -1,8 +1,31 @@
 # hola-proxy

+[![hola-proxy](https://snapcraft.io//hola-proxy/badge.svg)](https://snapcraft.io/hola-proxy)
+
 Standalone Hola proxy client. Just run it and it'll start plain HTTP proxy server forwarding traffic via Hola proxies of your choice. By default application listens port on 127.0.0.1:8080.

-Application is capable to forward traffic via proxies in datacenters (flag `-proxy-type direct`, default) or via peer proxies on residental IPs (consumer ISP) in that country (flag `-proxy-type peer`).
+Application is capable to forward traffic via proxies in datacenters (flag `-proxy-type direct`, default) or via peer proxies on residental IPs (consumer ISP) in that country (flag `-proxy-type pool` or `-proxy-type lum`).
+
+---
+
+:heart: :heart: :heart:
+
+You can say thanks to the author by donations to these wallets:
+
+- ETH: `0xB71250010e8beC90C5f9ddF408251eBA9dD7320e`
+- BTC:
+  - Legacy: `1N89PRvG1CSsUk9sxKwBwudN6TjTPQ1N8a`
+  - Segwit: `bc1qc0hcyxc000qf0ketv4r44ld7dlgmmu73rtlntw`
+
+---
+
+## Mirrors
+
+IPFS git mirror:
+
+```
+git clone https://ipfs.io/ipns/k51qzi5uqu5dkrgx0hozpy1tlggw5o0whtquyrjlc6pprhvbmczr6qtj4ocrv0 hola-proxy
+```

 ## Features

@@ -12,12 +35,37 @@ Application is capable to forward traffic via proxies in datacenters (flag `-pro

 ## Installation

+#### Binary download
+
 Pre-built binaries available on [releases](https://github.com/Snawoot/hola-proxy/releases/latest) page.

-Alternatively, you may install hola-proxy from source:
+#### From source
+
+Alternatively, you may install hola-proxy from source. Run within source directory

 ```
-go get github.com/Snawoot/hola-proxy
+make install
+```
+
+#### Docker
+
+Docker image is available as well. Here is an example for running proxy via DE as a background service:
+
+```sh
+docker run -d \
+    --security-opt no-new-privileges \
+    -p 127.0.0.1:8080:8080 \
+    --restart unless-stopped \
+    --name hola-proxy \
+    yarmak/hola-proxy -country de
+```
+
+#### Snap Store
+
+[![Get it from the Snap Store](https://snapcraft.io/static/images/badges/en/snap-store-black.svg)](https://snapcraft.io/hola-proxy)
+
+```bash
+sudo snap install hola-proxy
 ```

 ## Usage
@@ -42,8 +90,10 @@ dk - Denmark
 es - Spain
 fi - Finland
 fr - France
+gb - United Kingdom (Great Britain)
 gr - Greece
 hk - Hong Kong
+hr - Croatia
 hu - Hungary
 id - Indonesia
 ie - Ireland
@@ -77,21 +127,21 @@ $ ~/go/bin/hola-proxy -country de
 Or run proxy on residental IP:

 ```
-$ ~/go/bin/hola-proxy -country de -proxy-type peer
+$ ~/go/bin/hola-proxy -country de -proxy-type lum
 ```

 Also it is possible to export proxy addresses and credentials:

 ```
 $ ~/go/bin/hola-proxy -country de -list-proxies -limit 3
-Login: user-uuid-f4c2c3a8657640048e7243a807867d52
-Password: e194c4f457e0
-Proxy-Authorization: basic dXNlci11dWlkLWY0YzJjM2E4NjU3NjQwMDQ4ZTcyNDNhODA3ODY3ZDUyOmUxOTRjNGY0NTdlMA==
+Login: user-uuid-0a67c797b3214cbdb432b089c4b801cd
+Password: cd123c465901
+Proxy-Authorization: basic dXNlci11dWlkLTBhNjdjNzk3YjMyMTRjYmRiNDMyYjA4OWM0YjgwMWNkOmNkMTIzYzQ2NTkwMQ==

-Host,IP address,Direct port,Peer port,Vendor
-zagent90.hola.org,185.72.246.203,22222,22223,nqhost
-zagent249.hola.org,165.22.80.107,22222,22223,digitalocean
-zagent248.hola.org,165.22.65.3,22222,22223,digitalocean
+host,ip_address,direct,peer,hola,trial,trial_peer,vendor
+zagent783.hola.org,165.22.22.6,22222,22223,22224,22225,22226,digitalocean
+zagent830.hola.org,104.248.24.64,22222,22223,22224,22225,22226,digitalocean
+zagent248.hola.org,165.22.65.3,22222,22223,22224,22225,22226,digitalocean
 ```

 ## Synopsis
@@ -103,6 +153,10 @@ Usage of /home/user/go/bin/hola-proxy:
    	HTTP proxy listen address (default "127.0.0.1:8080")
  -country string
    	desired proxy location (default "us")
+  -dont-use-trial
+    	use regular ports instead of trial ports
+  -force-port-field string
+    	force specific port field/num (example 24232 or lum)
  -limit uint
    	amount of proxies in retrieved list (default 3)
  -list-countries
@@ -110,7 +164,9 @@ Usage of /home/user/go/bin/hola-proxy:
  -list-proxies
    	output proxy list and exit
  -proxy-type string
-    	proxy type: direct or peer (default "direct")
+    	proxy type: direct or peer or lum or virt or pool (default "direct")
+  -resolver string
+    	DNS/DoH/DoT resolver to workaround Hola blocked hosts. See https://github.com/ameshkov/dnslookup/ for upstream DNS URL format. (default "https://cloudflare-dns.com/dns-query")
  -rotate duration
    	rotate user ID once per given period (default 1h0m0s)
  -timeout duration
--- a/blocked-domains.txt
+++ b/blocked-domains.txt
@@ -0,0 +1,195 @@
+equinix.com
+digitalocean.com
+oceanconservancy.org
+mail.yahoo.com
+mail.yahoo.co.jp
+mail.aol.com
+mail.aol.fr
+mail.com
+gmx.com
+couponcabin.com
+outlook.live.com
+hotmail.live.com
+outlook.com
+mailto.space
+e.mail.ru
+login.sso.bluewin.ch
+secure.centurylink.net
+secureserver.net
+webmail.usfamily.net
+webmail.skymesh.net.au
+hanmail.net
+mail.rambler.ru
+freeola.co.uk
+webmail-04.datacenter.cha.cantv.net
+linustechtips.com
+3capp-mailcom-lxa01.server.lan
+noiholiday.com
+hostedemail.com
+heyholla.com
+hellixeducation.com
+unisalento.it
+secrel.com.br
+mailorama.fr
+kiwiirc.com
+derpibooru.org
+trixiebooru.org
+derpiboo.ru
+derpicdn.net
+alice.it
+vcwebmail.ocn.ad.jp
+tentaciones18.com
+ocn.ad.jp
+ocn.ne.jp
+webmail.numericable.fr
+webmail.scarlet.be
+webmailer.de
+mail.uk.tiscali.com
+elisa.fi
+saunalahti.fi
+globalgiving.org
+synacor.com
+knology.net
+netmail.pipex.net
+sony.com
+playstation.com
+playstation.net
+playstationnetwork.com
+sonymusic.com
+sonypictures.com
+sonyentertainmentnetwork.com
+perfora.net
+hmail.com
+gigablast.com
+126.com
+ono.com
+funded.today
+manenetheoffnewconne.ru
+dlfeed.com
+odbnfhbyagyz4.net
+pinformationbwarranties.ru
+musttthewithoutalsothas.ru
+bjkaolp4ds4z.com
+advseeking.com
+companolo.com
+mijnbankering-nl-server.com
+froekuge.com
+updateacces.org
+sophisticatiretaj.net
+soap4.me
+boriel.com
+ebb.mtn.co.za
+osbservices.vodacom.co.za
+apps.telkom.co.za
+holadebug.com
+fretebras.com.br
+megacupons.online
+vitacostapi.bbhosted.com
+mobilepayca.com
+mobilepayusa.org
+mobilepayusa.mobi
+mobilepayusa.net
+mobilepay-web.gaiareply.eu
+puffin.com
+miosmsclub.com
+linkedin.com
+ticketsnow.com
+playerline.com
+ticketmaster.com
+ticketmaster.com.mx
+livenation.com
+stubhub.com
+tickets.com
+craigslist.org
+kufar.by
+fastpeoplesearch.com
+btc4you.com
+elbitcoingratis.es
+btcmine.net
+virtualfaucet.net
+rawbitcoins.net
+freebitcoins4u.com
+canhasbitcoin.com
+bitcats.net
+faucetbtc.com
+bitcoins4free.me
+thefreebitcoins.net
+freebitcoins.me
+5mindoge.com
+freedoge.co.in
+moondoge.co.in
+moonbit.co.in
+bonusbitcoin.co
+bitcoinspace.net
+btc-faucet.co
+treebitcoin.com
+flatcoin.net
+baglitecoin.com
+moonliteco.in
+freebitco.in
+github.com
+smartadvices.com
+generictadalafilusa.com
+getitllc.com
+createyourownteeshirtonline.com
+mondino.it
+daum.net
+workbooks.com
+forum.qt.io
+radicalexploits.com
+craigslist.ca
+craigslist.co.uk
+bisaboard.de
+criusenergy.com
+arenagroup.com
+truqueira.com
+cratejoy.com
+gaynext.ca
+hispachan.org
+freenode.net
+exigent.com.au
+au.edu
+runsignup.com
+thegreekbookstore.com
+arriveonline.com.au
+reimageplus.com
+goso.info
+checkip.dyndns.org
+warezshare.org
+blocklist.de
+twiki.org
+intherooms.com
+globalinnovationexchange.org
+portal.webgods.de
+postfinance.ch
+gvtc.com
+cantv.net
+homepage-baukasten.de
+paginawebgratis.es
+own-free-website.com
+sitowebfaidate.it
+ma-page.fr
+homepage-konstruktor.ru
+bedava-sitem.com
+stronygratis.pl
+news.ycombinator.com
+tdchosting.dk
+infusionsoft.com
+puregaming.es
+blogalizate.com
+teftv.com
+porticolegal.com
+physicalmed.es
+www.htcmania.com
+www.tebeosfera.com
+grupopuntacana.rubypanel.com
+www.fansdeapple.com
+cerebriti.com
+educaciontrespuntocero.com
+pymescomercial.com
+creativat.com
+financiacionparaempresas.net
+moon.rightdns.com
+uptodate.com
+judoprincast.com
+office365.com
--- a/condlog.go
+++ b/condlog.go
@@ -1,58 +1,58 @@
 package main

 import (
-    "log"
-    "fmt"
+	"fmt"
+	"log"
 )

 const (
-    CRITICAL = 50
-    ERROR = 40
-    WARNING = 30
-    INFO = 20
-    DEBUG = 10
-    NOTSET = 0
+	CRITICAL = 50
+	ERROR    = 40
+	WARNING  = 30
+	INFO     = 20
+	DEBUG    = 10
+	NOTSET   = 0
 )

 type CondLogger struct {
-    logger *log.Logger
-    verbosity int
+	logger    *log.Logger
+	verbosity int
 }

 func (cl *CondLogger) Log(verb int, format string, v ...interface{}) error {
-    if verb >= cl.verbosity {
-        return cl.logger.Output(2, fmt.Sprintf(format, v...))
-    }
-    return nil
+	if verb >= cl.verbosity {
+		return cl.logger.Output(2, fmt.Sprintf(format, v...))
+	}
+	return nil
 }

 func (cl *CondLogger) log(verb int, format string, v ...interface{}) error {
-    if verb >= cl.verbosity {
-        return cl.logger.Output(3, fmt.Sprintf(format, v...))
-    }
-    return nil
+	if verb >= cl.verbosity {
+		return cl.logger.Output(3, fmt.Sprintf(format, v...))
+	}
+	return nil
 }

 func (cl *CondLogger) Critical(s string, v ...interface{}) error {
-    return cl.log(CRITICAL, "CRITICAL " + s, v...)
+	return cl.log(CRITICAL, "CRITICAL "+s, v...)
 }

 func (cl *CondLogger) Error(s string, v ...interface{}) error {
-    return cl.log(ERROR, "ERROR    " + s, v...)
+	return cl.log(ERROR, "ERROR    "+s, v...)
 }

 func (cl *CondLogger) Warning(s string, v ...interface{}) error {
-    return cl.log(WARNING, "WARNING  " + s, v...)
+	return cl.log(WARNING, "WARNING  "+s, v...)
 }

 func (cl *CondLogger) Info(s string, v ...interface{}) error {
-    return cl.log(INFO, "INFO     " + s, v...)
+	return cl.log(INFO, "INFO     "+s, v...)
 }

 func (cl *CondLogger) Debug(s string, v ...interface{}) error {
-    return cl.log(DEBUG, "DEBUG    " + s, v...)
+	return cl.log(DEBUG, "DEBUG    "+s, v...)
 }

 func NewCondLogger(logger *log.Logger, verbosity int) *CondLogger {
-    return &CondLogger{verbosity: verbosity, logger: logger}
+	return &CondLogger{verbosity: verbosity, logger: logger}
 }
--- a/credservice.go
+++ b/credservice.go
@@ -1,70 +1,82 @@
 package main

 import (
-    "time"
-    "sync"
-    "context"
+	"context"
+	"net/http"
+	"sync"
+	"time"
 )

 const DEFAULT_LIST_LIMIT = 3
-const API_CALL_ATTEMPTS = 3

 func CredService(interval, timeout time.Duration,
-                 country string,
-                 logger *CondLogger) (auth AuthProvider,
-                                      tunnels *ZGetTunnelsResponse,
-                                      err error) {
-    var mux sync.Mutex
-    var auth_header, user_uuid string
-    auth = func () (res string) {
-        (&mux).Lock()
-        res = auth_header
-        (&mux).Unlock()
-        return
-    }
+	country string,
+	proxytype string,
+	logger *CondLogger) (auth AuthProvider,
+	tunnels *ZGetTunnelsResponse,
+	err error) {
+	var mux sync.Mutex
+	var auth_header, user_uuid string
+	auth = func() (res string) {
+		(&mux).Lock()
+		res = auth_header
+		(&mux).Unlock()
+		return
+	}

-    for i := 0; i < API_CALL_ATTEMPTS ; i++ {
-        ctx, _ := context.WithTimeout(context.Background(), timeout)
-        tunnels, user_uuid, err = Tunnels(ctx, country, DEFAULT_LIST_LIMIT)
-        if err == nil {
-            break
-        }
-    }
-    if err != nil {
-        logger.Critical("Configuration bootstrap failed: %v", err)
-        return
-    }
-    auth_header = basic_auth_header(LOGIN_PREFIX + user_uuid,
-                                    tunnels.AgentKey)
-    go func() {
-        var (
-            err error
-            tuns *ZGetTunnelsResponse
-            user_uuid string
-        )
-        ticker := time.NewTicker(interval)
-        defer ticker.Stop()
-        for {
-            <-ticker.C
-            logger.Info("Rotating credentials...")
-            for i := 0; i < API_CALL_ATTEMPTS ; i++ {
-                ctx, _ := context.WithTimeout(context.Background(), timeout)
-                tuns, user_uuid, err = Tunnels(ctx, country, DEFAULT_LIST_LIMIT)
-                if err == nil {
-                    break
-                }
-            }
-            if err != nil {
-                logger.Error("Credential rotation failed after %d attempts. Error: %v",
-                             API_CALL_ATTEMPTS, err)
-            } else {
-                (&mux).Lock()
-                auth_header = basic_auth_header(LOGIN_PREFIX + user_uuid,
-                                                tuns.AgentKey)
-                (&mux).Unlock()
-                logger.Info("Credentials rotated successfully.")
-            }
-        }
-    }()
-    return
+	tx_res, tx_err := EnsureTransaction(context.Background(), timeout, func(ctx context.Context, client *http.Client) bool {
+		tunnels, user_uuid, err = Tunnels(ctx, client, country, proxytype, DEFAULT_LIST_LIMIT)
+		if err != nil {
+			logger.Error("Configuration bootstrap error: %v. Retrying with the fallback mechanism...", err)
+			return false
+		}
+		return true
+	})
+	if tx_err != nil {
+		logger.Critical("Transaction recovery mechanism failure: %v", tx_err)
+		err = tx_err
+		return
+	}
+	if !tx_res {
+		logger.Critical("All attempts failed.")
+		return
+	}
+	auth_header = basic_auth_header(LOGIN_PREFIX+user_uuid,
+		tunnels.AgentKey)
+	go func() {
+		var (
+			err       error
+			tuns      *ZGetTunnelsResponse
+			user_uuid string
+		)
+		ticker := time.NewTicker(interval)
+		defer ticker.Stop()
+		for {
+			<-ticker.C
+			logger.Info("Rotating credentials...")
+			tx_res, tx_err := EnsureTransaction(context.Background(), timeout, func(ctx context.Context, client *http.Client) bool {
+				tuns, user_uuid, err = Tunnels(ctx, client, country, proxytype, DEFAULT_LIST_LIMIT)
+				if err != nil {
+					logger.Error("Credential rotation error: %v. Retrying with the fallback mechanism...", err)
+					return false
+				}
+				return true
+			})
+			if tx_err != nil {
+				logger.Critical("Transaction recovery mechanism failure: %v", tx_err)
+				err = tx_err
+				continue
+			}
+			if !tx_res {
+				logger.Critical("All rotation attempts failed.")
+				continue
+			}
+			(&mux).Lock()
+			auth_header = basic_auth_header(LOGIN_PREFIX+user_uuid,
+				tuns.AgentKey)
+			(&mux).Unlock()
+			logger.Info("Credentials rotated successfully.")
+		}
+	}()
+	return
 }
--- a/csrand.go
+++ b/csrand.go
@@ -0,0 +1,23 @@
+package main
+
+import (
+	crand "crypto/rand"
+	"math/big"
+)
+
+type secureRandomSource struct{}
+
+var RandomSource secureRandomSource
+
+var int63Limit = big.NewInt(0).Lsh(big.NewInt(1), 63)
+
+func (_ secureRandomSource) Seed(_ int64) {
+}
+
+func (_ secureRandomSource) Int63() int64 {
+	randNum, err := crand.Int(crand.Reader, int63Limit)
+	if err != nil {
+		panic(err)
+	}
+	return randNum.Int64()
+}
--- a/go.mod
+++ b/go.mod
@@ -2,4 +2,9 @@ module github.com/Snawoot/hola-proxy

 go 1.13

-require github.com/google/uuid v1.1.1
+require (
+	github.com/AdguardTeam/dnsproxy v0.25.0
+	github.com/campoy/unique v0.0.0-20180121183637-88950e537e7e
+	github.com/google/uuid v1.1.1
+	github.com/miekg/dns v1.1.29
+)
--- a/go.sum
+++ b/go.sum
@@ -1,2 +1,64 @@
+github.com/AdguardTeam/dnsproxy v0.25.0 h1:BTUPrrwB01GeQW5d2Xx4pH5HOFXcZxN1MTeNXXuy6vQ=
+github.com/AdguardTeam/dnsproxy v0.25.0/go.mod h1:z2EljVLJQXFGZcP9pWABftXm9UxpLNqls7H6bMcIvEY=
+github.com/AdguardTeam/golibs v0.4.0 h1:4VX6LoOqFe9p9Gf55BeD8BvJD6M6RDYmgEiHrENE9KU=
+github.com/AdguardTeam/golibs v0.4.0/go.mod h1:skKsDKIBB7kkFflLJBpfGX+G8QFTx0WKUzB6TIgtUj4=
+github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY=
+github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSiWQsof+nXEI9bUVUyV6F53Fp89EuCh2EAA=
+github.com/aead/poly1305 v0.0.0-20180717145839-3fee0db0b635 h1:52m0LGchQBBVqJRyYYufQuIbVqRawmubW3OFGqK1ekw=
+github.com/aead/poly1305 v0.0.0-20180717145839-3fee0db0b635/go.mod h1:lmLxL+FV291OopO93Bwf9fQLQeLyt33VJRUg5VJ30us=
+github.com/ameshkov/dnscrypt v1.1.0 h1:2vAt5dD6ZmqlAxEAfzRcLBnkvdf8NI46Kn9InSwQbSI=
+github.com/ameshkov/dnscrypt v1.1.0/go.mod h1:ikduAxNLCTEfd1AaCgpIA5TgroIVQ8JY3Vb095fiFJg=
+github.com/ameshkov/dnsstamps v1.0.1 h1:LhGvgWDzhNJh+kBQd/AfUlq1vfVe109huiXw4JhnPug=
+github.com/ameshkov/dnsstamps v1.0.1/go.mod h1:Ii3eUu73dx4Vw5O4wjzmT5+lkCwovjzaEZZ4gKyIH5A=
+github.com/beefsack/go-rate v0.0.0-20180408011153-efa7637bb9b6/go.mod h1:6YNgTHLutezwnBvyneBbwvB8C82y3dcoOj5EQJIdGXA=
+github.com/campoy/unique v0.0.0-20180121183637-88950e537e7e h1:V9a67dfYqPLAvzk5hMQOXYJlZ4SLIXgyKIE+ZiHzgGQ=
+github.com/campoy/unique v0.0.0-20180121183637-88950e537e7e/go.mod h1:9IOqJGCPMSc6E5ydlp5NIonxObaeu/Iub/X03EKPVYo=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/go-test/deep v1.0.5/go.mod h1:QV8Hv/iy04NyLBxAdO9njL0iVPN1S4d/A3NVv1V36o8=
 github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/joomcode/errorx v1.0.1 h1:CalpDWz14ZHd68fIqluJasJosAewpz2TFaJALrUxjrk=
+github.com/joomcode/errorx v1.0.1/go.mod h1:kgco15ekB6cs+4Xjzo7SPeXzx38PbJzBwbnu9qfVNHQ=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/miekg/dns v1.1.29 h1:xHBEhR+t5RzcFJjBLJlax2daXOrTYtr9z4WdKEfWFzg=
+github.com/miekg/dns v1.1.29/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sparrc/go-ping v0.0.0-20190613174326-4e5b6552494c/go.mod h1:eMyUVp6f/5jnzM+3zahzl7q6UXLbgSc3MKg/+ow9QW0=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200403201458-baeed622b8d8 h1:fpnn/HnJONpIu6hkXi1u/7rR0NzilgWr4T0JmWkEitk=
+golang.org/x/crypto v0.0.0-20200403201458-baeed622b8d8/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d h1:nc5K6ox/4lTFbMVSL9WRR81ixkcwXThoiF6yf+R9scA=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- a/handler.go
+++ b/handler.go
@@ -1,93 +1,220 @@
 package main

 import (
-    "io"
-    "net/http"
-    "net/http/httputil"
-    "crypto/tls"
-    "strings"
-    "context"
-    "time"
-    "net/url"
+	"bufio"
+	"crypto/tls"
+	"io"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"strings"
 )

 type AuthProvider func() string

 type ProxyHandler struct {
-    auth AuthProvider
-    upstream string
-    logger *CondLogger
-    httptransport http.RoundTripper
+	auth          AuthProvider
+	upstream      string
+	logger        *CondLogger
+	httptransport http.RoundTripper
+	resolver      *Resolver
 }

-func NewProxyHandler(upstream string, auth AuthProvider, logger *CondLogger) *ProxyHandler {
-    proxyurl, err := url.Parse("https://" + upstream)
-    if err != nil {
-        panic(err)
-    }
+func NewProxyHandler(upstream string, auth AuthProvider, resolver *Resolver, logger *CondLogger) *ProxyHandler {
+	proxyurl, err := url.Parse("https://" + upstream)
+	if err != nil {
+		panic(err)
+	}
 	httptransport := &http.Transport{
-        Proxy: http.ProxyURL(proxyurl),
-    }
-    return &ProxyHandler{
-        auth: auth,
-        upstream: upstream,
-        logger: logger,
-        httptransport: httptransport,
-    }
+		Proxy: http.ProxyURL(proxyurl),
+	}
+	return &ProxyHandler{
+		auth:          auth,
+		upstream:      upstream,
+		logger:        logger,
+		httptransport: httptransport,
+		resolver:      resolver,
+	}
 }

 func (s *ProxyHandler) ServeHTTP(wr http.ResponseWriter, req *http.Request) {
 	s.logger.Info("Request: %v %v %v", req.RemoteAddr, req.Method, req.URL)
-    req.Header.Set("Proxy-Authorization", s.auth())
-    if strings.ToUpper(req.Method) == "CONNECT" {
-        rawreq, err := httputil.DumpRequest(req, false)
-        if err != nil {
-            s.logger.Error("Can't dump request: %v", err)
-            http.Error(wr, "Can't dump request", http.StatusInternalServerError)
-            return
-        }
-        conn, err := tls.Dial("tcp", s.upstream, nil)
-        if err != nil {
-            s.logger.Error("Can't dial tls upstream: %v", err)
-            http.Error(wr, "Can't dial tls upstream", http.StatusInternalServerError)
-            return
-        defer conn.Close()
-        }
-        hj, ok := wr.(http.Hijacker)
-		if !ok {
-            s.logger.Critical("Webserver doesn't support hijacking")
-			http.Error(wr, "Webserver doesn't support hijacking", http.StatusInternalServerError)
+	if strings.ToUpper(req.Method) == "CONNECT" {
+		req.Header.Set("Proxy-Authorization", s.auth())
+		rawreq, err := httputil.DumpRequest(req, false)
+		if err != nil {
+			s.logger.Error("Can't dump request: %v", err)
+			http.Error(wr, "Can't dump request", http.StatusInternalServerError)
 			return
 		}
-        localconn, _, err := hj.Hijack()
-        if err != nil {
-            s.logger.Error("Can't hijack client connection: %v", err)
-            http.Error(wr, "Can't hijack client connection", http.StatusInternalServerError)
-            return
-        }
-        var emptytime time.Time
-        err = localconn.SetDeadline(emptytime)
-        if err != nil {
-            s.logger.Error("Can't clear deadlines on local connection: %v", err)
-            http.Error(wr, "Can't clear deadlines on local connection", http.StatusInternalServerError)
-            return
-        }
-        conn.Write(rawreq)
-        proxy(context.TODO(), localconn, conn)
-    } else {
-        req.RequestURI = ""
-        delHopHeaders(req.Header)
-        resp, err := s.httptransport.RoundTrip(req)
-        if err != nil {
-            s.logger.Error("HTTP fetch error: %v", err)
-            http.Error(wr, "Server Error", http.StatusInternalServerError)
-            return
-        }
-        defer resp.Body.Close()
-        s.logger.Info("%v %v %v %v", req.RemoteAddr, req.Method, req.URL, resp.Status)
-        delHopHeaders(resp.Header)
-        copyHeader(wr.Header(), resp.Header)
-        wr.WriteHeader(resp.StatusCode)
-        io.Copy(wr, resp.Body)
-    }
+
+		conn, err := tls.Dial("tcp", s.upstream, nil)
+		if err != nil {
+			s.logger.Error("Can't dial tls upstream: %v", err)
+			http.Error(wr, "Can't dial tls upstream", http.StatusBadGateway)
+			return
+		}
+
+		_, err = conn.Write(rawreq)
+		if err != nil {
+			s.logger.Error("Can't write tls upstream: %v", err)
+			http.Error(wr, "Can't write tls upstream", http.StatusBadGateway)
+			return
+		}
+		bufrd := bufio.NewReader(conn)
+		proxyResp, err := http.ReadResponse(bufrd, req)
+		responseBytes := make([]byte, 0)
+		if err != nil {
+			s.logger.Error("Can't read response from upstream: %v", err)
+			http.Error(wr, "Can't read response from upstream", http.StatusBadGateway)
+			return
+		}
+
+		if proxyResp.StatusCode == http.StatusForbidden &&
+			proxyResp.Header.Get("X-Hola-Error") == "Forbidden Host" {
+			s.logger.Info("Request %s denied by upstream. Rescuing it with resolve&rewrite workaround.",
+				req.URL.String())
+			conn.Close()
+			conn, err = tls.Dial("tcp", s.upstream, nil)
+			if err != nil {
+				s.logger.Error("Can't dial tls upstream: %v", err)
+				http.Error(wr, "Can't dial tls upstream", http.StatusBadGateway)
+				return
+			}
+			defer conn.Close()
+			err = rewriteConnectReq(req, s.resolver)
+			if err != nil {
+				s.logger.Error("Can't rewrite request: %v", err)
+				http.Error(wr, "Can't rewrite request", http.StatusInternalServerError)
+				return
+			}
+			rawreq, err = httputil.DumpRequest(req, false)
+			if err != nil {
+				s.logger.Error("Can't dump request: %v", err)
+				http.Error(wr, "Can't dump request", http.StatusInternalServerError)
+				return
+			}
+			_, err = conn.Write(rawreq)
+			if err != nil {
+				s.logger.Error("Can't write tls upstream: %v", err)
+				http.Error(wr, "Can't write tls upstream", http.StatusBadGateway)
+				return
+			}
+		} else {
+			defer conn.Close()
+			responseBytes, err = httputil.DumpResponse(proxyResp, false)
+			if err != nil {
+				s.logger.Error("Can't dump response: %v", err)
+				http.Error(wr, "Can't dump response", http.StatusInternalServerError)
+				return
+			}
+			buffered := bufrd.Buffered()
+			if buffered > 0 {
+				trailer := make([]byte, buffered)
+				bufrd.Read(trailer)
+				responseBytes = append(responseBytes, trailer...)
+			}
+		}
+		bufrd = nil
+
+		// Upgrade client connection
+		localconn, _, err := hijack(wr)
+		if err != nil {
+			s.logger.Error("Can't hijack client connection: %v", err)
+			http.Error(wr, "Can't hijack client connection", http.StatusInternalServerError)
+			return
+		}
+		defer localconn.Close()
+
+		if len(responseBytes) > 0 {
+			_, err = localconn.Write(responseBytes)
+			if err != nil {
+				return
+			}
+		}
+		proxy(req.Context(), localconn, conn)
+	} else {
+		delHopHeaders(req.Header)
+		orig_req := req.Clone(req.Context())
+		req.RequestURI = ""
+		req.Header.Set("Proxy-Authorization", s.auth())
+		resp, err := s.httptransport.RoundTrip(req)
+		if err != nil {
+			s.logger.Error("HTTP fetch error: %v", err)
+			http.Error(wr, "Server Error", http.StatusInternalServerError)
+			return
+		}
+		if resp.StatusCode == http.StatusForbidden &&
+			resp.Header.Get("X-Hola-Error") == "Forbidden Host" {
+			s.logger.Info("Request %s denied by upstream. Rescuing it with resolve&tunnel workaround.",
+				req.URL.String())
+			resp.Body.Close()
+
+			// Prepare tunnel request
+			proxyReq, err := makeConnReq(orig_req.RequestURI, s.resolver)
+			if err != nil {
+				s.logger.Error("Can't rewrite request: %v", err)
+				http.Error(wr, "Can't rewrite request", http.StatusBadGateway)
+				return
+			}
+			proxyReq.Header.Set("Proxy-Authorization", s.auth())
+			rawreq, _ := httputil.DumpRequest(proxyReq, false)
+
+			// Prepare upstream TLS conn
+			conn, err := tls.Dial("tcp", s.upstream, nil)
+			if err != nil {
+				s.logger.Error("Can't dial tls upstream: %v", err)
+				http.Error(wr, "Can't dial tls upstream", http.StatusBadGateway)
+				return
+			}
+			defer conn.Close()
+
+			// Send proxy request
+			_, err = conn.Write(rawreq)
+			if err != nil {
+				s.logger.Error("Can't write tls upstream: %v", err)
+				http.Error(wr, "Can't write tls upstream", http.StatusBadGateway)
+				return
+			}
+
+			// Read proxy response
+			bufrd := bufio.NewReader(conn)
+			proxyResp, err := http.ReadResponse(bufrd, proxyReq)
+			if err != nil {
+				s.logger.Error("Can't read response from upstream: %v", err)
+				http.Error(wr, "Can't read response from upstream", http.StatusBadGateway)
+				return
+			}
+			if proxyResp.StatusCode != http.StatusOK {
+				delHopHeaders(proxyResp.Header)
+				copyHeader(wr.Header(), proxyResp.Header)
+				wr.WriteHeader(proxyResp.StatusCode)
+			}
+
+			// Send tunneled request
+			orig_req.RequestURI = ""
+			orig_req.Header.Set("Connection", "close")
+			rawreq, _ = httputil.DumpRequest(orig_req, false)
+			_, err = conn.Write(rawreq)
+			if err != nil {
+				s.logger.Error("Can't write tls upstream: %v", err)
+				http.Error(wr, "Can't write tls upstream", http.StatusBadGateway)
+				return
+			}
+
+			// Read tunneled response
+			resp, err = http.ReadResponse(bufrd, orig_req)
+			if err != nil {
+				s.logger.Error("Can't read response from upstream: %v", err)
+				http.Error(wr, "Can't read response from upstream", http.StatusBadGateway)
+				return
+			}
+		}
+		defer resp.Body.Close()
+		s.logger.Info("%v %v %v %v", req.RemoteAddr, req.Method, req.URL, resp.Status)
+		delHopHeaders(resp.Header)
+		copyHeader(wr.Header(), resp.Header)
+		wr.WriteHeader(resp.StatusCode)
+		io.Copy(wr, resp.Body)
+	}
 }
--- a/holaapi.go
+++ b/holaapi.go
@@ -1,20 +1,28 @@
 package main

 import (
-    "context"
-    "net/http"
-    "net/url"
-    "io/ioutil"
-    "encoding/json"
-    "encoding/hex"
-    "github.com/google/uuid"
-    "bytes"
-    "strconv"
-    "math/rand"
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"math/rand"
+	"net"
+	"net/http"
+	"net/url"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/campoy/unique"
+	"github.com/google/uuid"
 )

-const USER_AGENT = "Mozilla/5.0 (X11; Fedora; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36"
-const EXT_VER = "1.164.641"
+const USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.72 Safari/537.36"
+const EXT_VER = "1.181.350"
 const EXT_BROWSER = "chrome"
 const PRODUCT = "cws"
 const CCGI_URL = "https://client.hola.org/client_cgi/"
@@ -22,134 +30,350 @@ const VPN_COUNTRIES_URL = CCGI_URL + "vpn_countries.json"
 const BG_INIT_URL = CCGI_URL + "background_init"
 const ZGETTUNNELS_URL = CCGI_URL + "zgettunnels"
 const LOGIN_PREFIX = "user-uuid-"
+const FALLBACK_CONF_URL = "https://www.dropbox.com/s/jemizcvpmf2qb9v/cloud_failover.conf?dl=1"
+const AGENT_SUFFIX = ".hola.org"
+
+var TemporaryBanError = errors.New("temporary ban detected")
+var PermanentBanError = errors.New("permanent ban detected")

 type CountryList []string

 type BgInitResponse struct {
-    Ver string `json:"ver"`
-    Key int64 `json:"key"`
-    Country string `json:"country"`
+	Ver       string `json:"ver"`
+	Key       int64  `json:"key"`
+	Country   string `json:"country"`
+	Blocked   bool   `json:"blocked,omitempty"`
+	Permanent bool   `json:"permanent,omitempty"`
 }

 type PortMap struct {
-    Direct uint16 `json:"direct"`
-    Hola uint16 `json:"hola"`
-    Peer uint16 `json:"peer"`
-    Trial uint16 `json:"trial"`
-    TrialPeer uint16 `json:"trial_peer"`
+	Direct    uint16 `json:"direct"`
+	Hola      uint16 `json:"hola"`
+	Peer      uint16 `json:"peer"`
+	Trial     uint16 `json:"trial"`
+	TrialPeer uint16 `json:"trial_peer"`
 }

 type ZGetTunnelsResponse struct {
-    AgentKey string `json:"agent_key"`
-    AgentTypes map[string]string `json:"agent_types"`
-    IPList map[string]string `json:"ip_list"`
-    Port PortMap `json:"port"`
-    Protocol map[string]string `json:"protocol"`
-    Vendor map[string]string `json:"vendor"`
-    Ztun map[string][]string `json:"ztun"`
+	AgentKey   string              `json:"agent_key"`
+	AgentTypes map[string]string   `json:"agent_types"`
+	IPList     map[string]string   `json:"ip_list"`
+	Port       PortMap             `json:"port"`
+	Protocol   map[string]string   `json:"protocol"`
+	Vendor     map[string]string   `json:"vendor"`
+	Ztun       map[string][]string `json:"ztun"`
 }

-func do_req(ctx context.Context, method, url string, query, data url.Values) ([]byte, error) {
-    var (
-        client http.Client
-        req *http.Request
-        err error
-    )
-    if method == "" {
-        method = "GET"
-    }
-    if data == nil {
-        req, err = http.NewRequestWithContext(ctx, method, url, nil)
-    } else {
-        req, err = http.NewRequestWithContext(ctx,
-                                              method,
-                                              url,
-                                              bytes.NewReader([]byte(data.Encode())))
-    }
-    if err != nil {
-        return nil, err
-    }
-    if data != nil {
-        req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-    }
-    if query != nil {
-        req.URL.RawQuery = query.Encode()
-    }
-    req.Header.Set("User-Agent", USER_AGENT)
-    resp, err := client.Do(req)
-    if err != nil {
-        return nil, err
-    }
-    body, err := ioutil.ReadAll(resp.Body)
-    resp.Body.Close()
-    if err != nil {
-        return nil, err
-    }
-    return body, nil
+type FallbackAgent struct {
+	Name string `json:"name"`
+	IP   string `json:"ip"`
+	Port uint16 `json:"port"`
 }

-func VPNCountries(ctx context.Context) (res CountryList, err error) {
-    params := make(url.Values)
-    params.Add("browser", EXT_BROWSER)
-    data, err := do_req(ctx, "", VPN_COUNTRIES_URL, params, nil)
-    if err != nil {
-        return nil, err
-    }
-    err = json.Unmarshal(data, &res)
-    return
+type fallbackConfResponse struct {
+	Agents    []FallbackAgent `json:"agents"`
+	UpdatedAt int64           `json:"updated_ts"`
+	TTL       int64           `json:"ttl_ms"`
 }

-func background_init(ctx context.Context, user_uuid string) (res BgInitResponse, reterr error) {
-    post_data := make(url.Values)
-    post_data.Add("login", "1")
-    post_data.Add("ver", EXT_VER)
-    qs := make(url.Values)
-    qs.Add("uuid", user_uuid)
-    resp, err := do_req(ctx, "POST", BG_INIT_URL, qs, post_data)
-    if err != nil {
-        reterr = err
-        return
-    }
-    reterr = json.Unmarshal(resp, &res)
-    return
+type FallbackConfig struct {
+	Agents    []FallbackAgent
+	UpdatedAt time.Time
+	TTL       time.Duration
+}
+
+func (c *FallbackConfig) UnmarshalJSON(data []byte) error {
+	r := fallbackConfResponse{}
+	err := json.Unmarshal(data, &r)
+	if err != nil {
+		return err
+	}
+	c.Agents = r.Agents
+	c.UpdatedAt = time.Unix(r.UpdatedAt/1000, (r.UpdatedAt%1000)*1000000)
+	c.TTL = time.Duration(r.TTL * 1000000)
+	return nil
+}
+
+func (c *FallbackConfig) Expired() bool {
+	return time.Now().After(c.UpdatedAt.Add(c.TTL))
+}
+
+func (c *FallbackConfig) ShuffleAgents() {
+	rand.New(RandomSource).Shuffle(len(c.Agents), func(i, j int) {
+		c.Agents[i], c.Agents[j] = c.Agents[j], c.Agents[i]
+	})
+}
+
+func (c *FallbackConfig) Clone() *FallbackConfig {
+	return &FallbackConfig{
+		Agents: append([]FallbackAgent(nil), c.Agents...),
+		UpdatedAt: c.UpdatedAt,
+		TTL: c.TTL,
+	}
+}
+
+func (a *FallbackAgent) ToProxy() *url.URL {
+	return &url.URL{
+		Scheme: "https",
+		Host: net.JoinHostPort(a.Name+AGENT_SUFFIX,
+			fmt.Sprintf("%d", a.Port)),
+	}
+}
+
+func do_req(ctx context.Context, client *http.Client, method, url string, query, data url.Values) ([]byte, error) {
+	var (
+		req *http.Request
+		err error
+	)
+	if method == "" {
+		method = "GET"
+	}
+	if data == nil {
+		req, err = http.NewRequestWithContext(ctx, method, url, nil)
+	} else {
+		req, err = http.NewRequestWithContext(ctx,
+			method,
+			url,
+			bytes.NewReader([]byte(data.Encode())))
+	}
+	if err != nil {
+		return nil, err
+	}
+	if data != nil {
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	}
+	if query != nil {
+		req.URL.RawQuery = query.Encode()
+	}
+	req.Header.Set("User-Agent", USER_AGENT)
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	switch resp.StatusCode {
+	case http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent:
+	default:
+		return nil, errors.New(fmt.Sprintf("Bad HTTP response: %s", resp.Status))
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	resp.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+	return body, nil
+}
+
+func VPNCountries(ctx context.Context, client *http.Client) (res CountryList, err error) {
+	params := make(url.Values)
+	params.Add("browser", EXT_BROWSER)
+	data, err := do_req(ctx, client, "", VPN_COUNTRIES_URL, params, nil)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal(data, &res)
+	for _, a := range res {
+		if a == "uk" {
+			res = append(res, "gb")
+		}
+	}
+	less := func(i, j int) bool { return res[i] < res[j] }
+	unique.Slice(&res, less)
+	return
+}
+
+func background_init(ctx context.Context, client *http.Client, user_uuid string) (res BgInitResponse, reterr error) {
+	post_data := make(url.Values)
+	post_data.Add("login", "1")
+	post_data.Add("ver", EXT_VER)
+	qs := make(url.Values)
+	qs.Add("uuid", user_uuid)
+	resp, err := do_req(ctx, client, "POST", BG_INIT_URL, qs, post_data)
+	if err != nil {
+		reterr = err
+		return
+	}
+
+	reterr = json.Unmarshal(resp, &res)
+	if reterr == nil && res.Blocked {
+		if res.Permanent {
+			reterr = PermanentBanError
+		} else {
+			reterr = TemporaryBanError
+		}
+	}
+	return
 }

 func zgettunnels(ctx context.Context,
-                 user_uuid string,
-                 session_key int64,
-                 country string,
-                 limit uint) (res *ZGetTunnelsResponse, reterr error) {
-    var tunnels ZGetTunnelsResponse
-    params := make(url.Values)
-    params.Add("country", country)
-    params.Add("limit", strconv.FormatInt(int64(limit), 10))
-    params.Add("ping_id", strconv.FormatFloat(rand.Float64(), 'f', -1, 64))
-    params.Add("ext_ver", EXT_VER)
-    params.Add("browser", EXT_BROWSER)
-    params.Add("product", PRODUCT)
-    params.Add("uuid", user_uuid)
-    params.Add("session_key", strconv.FormatInt(session_key, 10))
-    params.Add("is_premium", "0")
-    data, err := do_req(ctx, "", ZGETTUNNELS_URL, params, nil)
-    if err != nil {
-        reterr = err
-        return
-    }
-    reterr = json.Unmarshal(data, &tunnels)
-    res = &tunnels
-    return
+	client *http.Client,
+	user_uuid string,
+	session_key int64,
+	country string,
+	proxy_type string,
+	limit uint) (res *ZGetTunnelsResponse, reterr error) {
+	var tunnels ZGetTunnelsResponse
+	params := make(url.Values)
+	if proxy_type == "lum" {
+		params.Add("country", country+".pool_lum_"+country+"_shared")
+	} else if proxy_type == "virt" { // seems to be for brazil and japan only
+		params.Add("country", country+".pool_virt_pool_"+country)
+	} else if proxy_type == "peer" {
+		//params.Add("country", country + ".peer")
+		params.Add("country", country)
+	} else if proxy_type == "pool" {
+		params.Add("country", country+".pool")
+	} else { // direct or skip
+		params.Add("country", country)
+	}
+	params.Add("limit", strconv.FormatInt(int64(limit), 10))
+	params.Add("ping_id", strconv.FormatFloat(rand.New(RandomSource).Float64(), 'f', -1, 64))
+	params.Add("ext_ver", EXT_VER)
+	params.Add("browser", EXT_BROWSER)
+	params.Add("product", PRODUCT)
+	params.Add("uuid", user_uuid)
+	params.Add("session_key", strconv.FormatInt(session_key, 10))
+	params.Add("is_premium", "0")
+	data, err := do_req(ctx, client, "", ZGETTUNNELS_URL, params, nil)
+	if err != nil {
+		reterr = err
+		return
+	}
+	reterr = json.Unmarshal(data, &tunnels)
+	res = &tunnels
+	return
+}
+
+func fetchFallbackConfig(ctx context.Context) (*FallbackConfig, error) {
+	confRaw, err := do_req(ctx, &http.Client{}, "", FALLBACK_CONF_URL, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	l := len(confRaw)
+	if l < 4 {
+		return nil, errors.New("bad response length from fallback conf URL")
+	}
+
+	buf := &bytes.Buffer{}
+	buf.Grow(l)
+	buf.Write(confRaw[l-3:])
+	buf.Write(confRaw[:l-3])
+
+	b64dec := base64.NewDecoder(base64.RawStdEncoding, buf)
+	jdec := json.NewDecoder(b64dec)
+	fbc := &FallbackConfig{}
+
+	err = jdec.Decode(fbc)
+	if err != nil {
+		return nil, err
+	}
+
+	if fbc.Expired() {
+		return nil, errors.New("fetched expired fallback config")
+	}
+
+	fbc.ShuffleAgents()
+	return fbc, nil
+}
+
+var (
+	fbcMux    sync.Mutex
+	cachedFBC *FallbackConfig
+)
+
+func GetFallbackProxies(ctx context.Context) (*FallbackConfig, error) {
+	fbcMux.Lock()
+	defer fbcMux.Unlock()
+
+	var (
+		fbc *FallbackConfig
+		err error
+	)
+
+	if cachedFBC == nil || cachedFBC.Expired() {
+		fbc, err = fetchFallbackConfig(ctx)
+		if err != nil {
+			return nil, err
+		}
+		cachedFBC = fbc
+	} else {
+		fbc = cachedFBC
+	}
+
+	return fbc.Clone(), nil
 }

 func Tunnels(ctx context.Context,
-             country string,
-             limit uint) (res *ZGetTunnelsResponse, user_uuid string, reterr error) {
-    u := uuid.New()
-    user_uuid = hex.EncodeToString(u[:])
-    initres, err := background_init(ctx, user_uuid)
-    if err != nil {
-        reterr = err
-        return
-    }
-    res, reterr = zgettunnels(ctx, user_uuid, initres.Key, country, limit)
-    return
+	client *http.Client,
+	country string,
+	proxy_type string,
+	limit uint) (res *ZGetTunnelsResponse, user_uuid string, reterr error) {
+	u := uuid.New()
+	user_uuid = hex.EncodeToString(u[:])
+	initres, err := background_init(ctx, client, user_uuid)
+	if err != nil {
+		reterr = err
+		return
+	}
+	res, reterr = zgettunnels(ctx, client, user_uuid, initres.Key, country, proxy_type, limit)
+	return
+}
+
+// Returns default http client with a proxy override
+func httpClientWithProxy(agent *FallbackAgent) *http.Client {
+	t := &http.Transport{
+		ForceAttemptHTTP2:     true,
+		MaxIdleConns:          100,
+		IdleConnTimeout:       90 * time.Second,
+		TLSHandshakeTimeout:   10 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
+	}
+	dialer := &net.Dialer{
+		Timeout:   30 * time.Second,
+		KeepAlive: 30 * time.Second,
+	}
+	if agent == nil {
+		t.DialContext = dialer.DialContext
+	} else {
+		t.Proxy = http.ProxyURL(agent.ToProxy())
+		addr := net.JoinHostPort(agent.IP, fmt.Sprintf("%d", agent.Port))
+		t.DialContext = func(ctx context.Context, _, _ string) (net.Conn, error) {
+			return dialer.DialContext(ctx, "tcp4", addr)
+		}
+	}
+	return &http.Client{
+		Transport: t,
+	}
+}
+
+func EnsureTransaction(baseCtx context.Context, txnTimeout time.Duration, txn func(context.Context, *http.Client) bool) (bool, error) {
+	client := httpClientWithProxy(nil)
+	defer client.CloseIdleConnections()
+
+	ctx, cancel := context.WithTimeout(baseCtx, txnTimeout)
+	defer cancel()
+
+	if txn(ctx, client) {
+		return true, nil
+	}
+
+	// Fallback needed
+	fbc, err := GetFallbackProxies(baseCtx)
+	if err != nil {
+		return false, err
+	}
+
+	for _, agent := range fbc.Agents {
+		client = httpClientWithProxy(&agent)
+		defer client.CloseIdleConnections()
+
+		ctx, cancel = context.WithTimeout(baseCtx, txnTimeout)
+		defer cancel()
+
+		if txn(ctx, client) {
+			return true, nil
+		}
+	}
+
+	return false, nil
 }
--- a/hooks/build
+++ b/hooks/build
@@ -0,0 +1,2 @@
+#!/bin/bash
+docker build --build-arg GIT_DESC="$(git describe)" -f "$DOCKERFILE_PATH" -t "$IMAGE_NAME" .
--- a/iso3166.go
+++ b/iso3166.go
@@ -3,252 +3,252 @@ package main
 var ISO3166 map[string]string

 func init() {
-    ISO3166 = map[string]string{
-        "AD": "Andorra",
-        "AE": "United Arab Emirates",
-        "AF": "Afghanistan",
-        "AG": "Antigua & Barbuda",
-        "AI": "Anguilla",
-        "AL": "Albania",
-        "AM": "Armenia",
-        "AN": "Netherlands Antilles",
-        "AO": "Angola",
-        "AQ": "Antarctica",
-        "AR": "Argentina",
-        "AS": "American Samoa",
-        "AT": "Austria",
-        "AU": "Australia",
-        "AW": "Aruba",
-        "AZ": "Azerbaijan",
-        "BA": "Bosnia and Herzegovina",
-        "BB": "Barbados",
-        "BD": "Bangladesh",
-        "BE": "Belgium",
-        "BF": "Burkina Faso",
-        "BG": "Bulgaria",
-        "BH": "Bahrain",
-        "BI": "Burundi",
-        "BJ": "Benin",
-        "BM": "Bermuda",
-        "BN": "Brunei Darussalam",
-        "BO": "Bolivia",
-        "BR": "Brazil",
-        "BS": "Bahama",
-        "BT": "Bhutan",
-        "BU": "Burma (no longer exists)",
-        "BV": "Bouvet Island",
-        "BW": "Botswana",
-        "BY": "Belarus",
-        "BZ": "Belize",
-        "CA": "Canada",
-        "CC": "Cocos (Keeling) Islands",
-        "CF": "Central African Republic",
-        "CG": "Congo",
-        "CH": "Switzerland",
-        "CI": "Cote D\"ivoire (Ivory Coast)",
-        "CK": "Cook Iislands",
-        "CL": "Chile",
-        "CM": "Cameroon",
-        "CN": "China",
-        "CO": "Colombia",
-        "CR": "Costa Rica",
-        "CS": "Czechoslovakia (no longer exists)",
-        "CU": "Cuba",
-        "CV": "Cape Verde",
-        "CX": "Christmas Island",
-        "CY": "Cyprus",
-        "CZ": "Czech Republic",
-        "DD": "German Democratic Republic (no longer exists)",
-        "DE": "Germany",
-        "DJ": "Djibouti",
-        "DK": "Denmark",
-        "DM": "Dominica",
-        "DO": "Dominican Republic",
-        "DZ": "Algeria",
-        "EC": "Ecuador",
-        "EE": "Estonia",
-        "EG": "Egypt",
-        "EH": "Western Sahara",
-        "ER": "Eritrea",
-        "ES": "Spain",
-        "ET": "Ethiopia",
-        "FI": "Finland",
-        "FJ": "Fiji",
-        "FK": "Falkland Islands (Malvinas)",
-        "FM": "Micronesia",
-        "FO": "Faroe Islands",
-        "FR": "France",
-        "FX": "France, Metropolitan",
-        "GA": "Gabon",
-        "GB": "United Kingdom (Great Britain)",
-        "GD": "Grenada",
-        "GE": "Georgia",
-        "GF": "French Guiana",
-        "GH": "Ghana",
-        "GI": "Gibraltar",
-        "GL": "Greenland",
-        "GM": "Gambia",
-        "GN": "Guinea",
-        "GP": "Guadeloupe",
-        "GQ": "Equatorial Guinea",
-        "GR": "Greece",
-        "GS": "South Georgia and the South Sandwich Islands",
-        "GT": "Guatemala",
-        "GU": "Guam",
-        "GW": "Guinea-Bissau",
-        "GY": "Guyana",
-        "HK": "Hong Kong",
-        "HM": "Heard & McDonald Islands",
-        "HN": "Honduras",
-        "HR": "Croatia",
-        "HT": "Haiti",
-        "HU": "Hungary",
-        "ID": "Indonesia",
-        "IE": "Ireland",
-        "IL": "Israel",
-        "IN": "India",
-        "IO": "British Indian Ocean Territory",
-        "IQ": "Iraq",
-        "IR": "Islamic Republic of Iran",
-        "IS": "Iceland",
-        "IT": "Italy",
-        "JM": "Jamaica",
-        "JO": "Jordan",
-        "JP": "Japan",
-        "KE": "Kenya",
-        "KG": "Kyrgyzstan",
-        "KH": "Cambodia",
-        "KI": "Kiribati",
-        "KM": "Comoros",
-        "KN": "St. Kitts and Nevis",
-        "KP": "Korea, Democratic People\"s Republic of",
-        "KR": "Korea, Republic of",
-        "KW": "Kuwait",
-        "KY": "Cayman Islands",
-        "KZ": "Kazakhstan",
-        "LA": "Lao People\"s Democratic Republic",
-        "LB": "Lebanon",
-        "LC": "Saint Lucia",
-        "LI": "Liechtenstein",
-        "LK": "Sri Lanka",
-        "LR": "Liberia",
-        "LS": "Lesotho",
-        "LT": "Lithuania",
-        "LU": "Luxembourg",
-        "LV": "Latvia",
-        "LY": "Libyan Arab Jamahiriya",
-        "MA": "Morocco",
-        "MC": "Monaco",
-        "MD": "Moldova, Republic of",
-        "MG": "Madagascar",
-        "MH": "Marshall Islands",
-        "ML": "Mali",
-        "MN": "Mongolia",
-        "MM": "Myanmar",
-        "MO": "Macau",
-        "MP": "Northern Mariana Islands",
-        "MQ": "Martinique",
-        "MR": "Mauritania",
-        "MS": "Monserrat",
-        "MT": "Malta",
-        "MU": "Mauritius",
-        "MV": "Maldives",
-        "MW": "Malawi",
-        "MX": "Mexico",
-        "MY": "Malaysia",
-        "MZ": "Mozambique",
-        "NA": "Namibia",
-        "NC": "New Caledonia",
-        "NE": "Niger",
-        "NF": "Norfolk Island",
-        "NG": "Nigeria",
-        "NI": "Nicaragua",
-        "NL": "Netherlands",
-        "NO": "Norway",
-        "NP": "Nepal",
-        "NR": "Nauru",
-        "NT": "Neutral Zone (no longer exists)",
-        "NU": "Niue",
-        "NZ": "New Zealand",
-        "OM": "Oman",
-        "PA": "Panama",
-        "PE": "Peru",
-        "PF": "French Polynesia",
-        "PG": "Papua New Guinea",
-        "PH": "Philippines",
-        "PK": "Pakistan",
-        "PL": "Poland",
-        "PM": "St. Pierre & Miquelon",
-        "PN": "Pitcairn",
-        "PR": "Puerto Rico",
-        "PT": "Portugal",
-        "PW": "Palau",
-        "PY": "Paraguay",
-        "QA": "Qatar",
-        "RE": "Reunion",
-        "RO": "Romania",
-        "RU": "Russian Federation",
-        "RW": "Rwanda",
-        "SA": "Saudi Arabia",
-        "SB": "Solomon Islands",
-        "SC": "Seychelles",
-        "SD": "Sudan",
-        "SE": "Sweden",
-        "SG": "Singapore",
-        "SH": "St. Helena",
-        "SI": "Slovenia",
-        "SJ": "Svalbard & Jan Mayen Islands",
-        "SK": "Slovakia",
-        "SL": "Sierra Leone",
-        "SM": "San Marino",
-        "SN": "Senegal",
-        "SO": "Somalia",
-        "SR": "Suriname",
-        "ST": "Sao Tome & Principe",
-        "SU": "Union of Soviet Socialist Republics (no longer exists)",
-        "SV": "El Salvador",
-        "SY": "Syrian Arab Republic",
-        "SZ": "Swaziland",
-        "TC": "Turks & Caicos Islands",
-        "TD": "Chad",
-        "TF": "French Southern Territories",
-        "TG": "Togo",
-        "TH": "Thailand",
-        "TJ": "Tajikistan",
-        "TK": "Tokelau",
-        "TM": "Turkmenistan",
-        "TN": "Tunisia",
-        "TO": "Tonga",
-        "TP": "East Timor",
-        "TR": "Turkey",
-        "TT": "Trinidad & Tobago",
-        "TV": "Tuvalu",
-        "TW": "Taiwan, Province of China",
-        "TZ": "Tanzania, United Republic of",
-        "UA": "Ukraine",
-        "UG": "Uganda",
-        "UK": "United Kingdom",
-        "UM": "United States Minor Outlying Islands",
-        "US": "United States of America",
-        "UY": "Uruguay",
-        "UZ": "Uzbekistan",
-        "VA": "Vatican City State (Holy See)",
-        "VC": "St. Vincent & the Grenadines",
-        "VE": "Venezuela",
-        "VG": "British Virgin Islands",
-        "VI": "United States Virgin Islands",
-        "VN": "Viet Nam",
-        "VU": "Vanuatu",
-        "WF": "Wallis & Futuna Islands",
-        "WS": "Samoa",
-        "YD": "Democratic Yemen (no longer exists)",
-        "YE": "Yemen",
-        "YT": "Mayotte",
-        "YU": "Yugoslavia",
-        "ZA": "South Africa",
-        "ZM": "Zambia",
-        "ZR": "Zaire",
-        "ZW": "Zimbabwe",
-        "ZZ": "Unknown or unspecified country",
-    }
+	ISO3166 = map[string]string{
+		"AD": "Andorra",
+		"AE": "United Arab Emirates",
+		"AF": "Afghanistan",
+		"AG": "Antigua & Barbuda",
+		"AI": "Anguilla",
+		"AL": "Albania",
+		"AM": "Armenia",
+		"AN": "Netherlands Antilles",
+		"AO": "Angola",
+		"AQ": "Antarctica",
+		"AR": "Argentina",
+		"AS": "American Samoa",
+		"AT": "Austria",
+		"AU": "Australia",
+		"AW": "Aruba",
+		"AZ": "Azerbaijan",
+		"BA": "Bosnia and Herzegovina",
+		"BB": "Barbados",
+		"BD": "Bangladesh",
+		"BE": "Belgium",
+		"BF": "Burkina Faso",
+		"BG": "Bulgaria",
+		"BH": "Bahrain",
+		"BI": "Burundi",
+		"BJ": "Benin",
+		"BM": "Bermuda",
+		"BN": "Brunei Darussalam",
+		"BO": "Bolivia",
+		"BR": "Brazil",
+		"BS": "Bahama",
+		"BT": "Bhutan",
+		"BU": "Burma (no longer exists)",
+		"BV": "Bouvet Island",
+		"BW": "Botswana",
+		"BY": "Belarus",
+		"BZ": "Belize",
+		"CA": "Canada",
+		"CC": "Cocos (Keeling) Islands",
+		"CF": "Central African Republic",
+		"CG": "Congo",
+		"CH": "Switzerland",
+		"CI": "Cote D\"ivoire (Ivory Coast)",
+		"CK": "Cook Iislands",
+		"CL": "Chile",
+		"CM": "Cameroon",
+		"CN": "China",
+		"CO": "Colombia",
+		"CR": "Costa Rica",
+		"CS": "Czechoslovakia (no longer exists)",
+		"CU": "Cuba",
+		"CV": "Cape Verde",
+		"CX": "Christmas Island",
+		"CY": "Cyprus",
+		"CZ": "Czech Republic",
+		"DD": "German Democratic Republic (no longer exists)",
+		"DE": "Germany",
+		"DJ": "Djibouti",
+		"DK": "Denmark",
+		"DM": "Dominica",
+		"DO": "Dominican Republic",
+		"DZ": "Algeria",
+		"EC": "Ecuador",
+		"EE": "Estonia",
+		"EG": "Egypt",
+		"EH": "Western Sahara",
+		"ER": "Eritrea",
+		"ES": "Spain",
+		"ET": "Ethiopia",
+		"FI": "Finland",
+		"FJ": "Fiji",
+		"FK": "Falkland Islands (Malvinas)",
+		"FM": "Micronesia",
+		"FO": "Faroe Islands",
+		"FR": "France",
+		"FX": "France, Metropolitan",
+		"GA": "Gabon",
+		"GB": "United Kingdom (Great Britain)",
+		"GD": "Grenada",
+		"GE": "Georgia",
+		"GF": "French Guiana",
+		"GH": "Ghana",
+		"GI": "Gibraltar",
+		"GL": "Greenland",
+		"GM": "Gambia",
+		"GN": "Guinea",
+		"GP": "Guadeloupe",
+		"GQ": "Equatorial Guinea",
+		"GR": "Greece",
+		"GS": "South Georgia and the South Sandwich Islands",
+		"GT": "Guatemala",
+		"GU": "Guam",
+		"GW": "Guinea-Bissau",
+		"GY": "Guyana",
+		"HK": "Hong Kong",
+		"HM": "Heard & McDonald Islands",
+		"HN": "Honduras",
+		"HR": "Croatia",
+		"HT": "Haiti",
+		"HU": "Hungary",
+		"ID": "Indonesia",
+		"IE": "Ireland",
+		"IL": "Israel",
+		"IN": "India",
+		"IO": "British Indian Ocean Territory",
+		"IQ": "Iraq",
+		"IR": "Islamic Republic of Iran",
+		"IS": "Iceland",
+		"IT": "Italy",
+		"JM": "Jamaica",
+		"JO": "Jordan",
+		"JP": "Japan",
+		"KE": "Kenya",
+		"KG": "Kyrgyzstan",
+		"KH": "Cambodia",
+		"KI": "Kiribati",
+		"KM": "Comoros",
+		"KN": "St. Kitts and Nevis",
+		"KP": "Korea, Democratic People\"s Republic of",
+		"KR": "Korea, Republic of",
+		"KW": "Kuwait",
+		"KY": "Cayman Islands",
+		"KZ": "Kazakhstan",
+		"LA": "Lao People\"s Democratic Republic",
+		"LB": "Lebanon",
+		"LC": "Saint Lucia",
+		"LI": "Liechtenstein",
+		"LK": "Sri Lanka",
+		"LR": "Liberia",
+		"LS": "Lesotho",
+		"LT": "Lithuania",
+		"LU": "Luxembourg",
+		"LV": "Latvia",
+		"LY": "Libyan Arab Jamahiriya",
+		"MA": "Morocco",
+		"MC": "Monaco",
+		"MD": "Moldova, Republic of",
+		"MG": "Madagascar",
+		"MH": "Marshall Islands",
+		"ML": "Mali",
+		"MN": "Mongolia",
+		"MM": "Myanmar",
+		"MO": "Macau",
+		"MP": "Northern Mariana Islands",
+		"MQ": "Martinique",
+		"MR": "Mauritania",
+		"MS": "Monserrat",
+		"MT": "Malta",
+		"MU": "Mauritius",
+		"MV": "Maldives",
+		"MW": "Malawi",
+		"MX": "Mexico",
+		"MY": "Malaysia",
+		"MZ": "Mozambique",
+		"NA": "Namibia",
+		"NC": "New Caledonia",
+		"NE": "Niger",
+		"NF": "Norfolk Island",
+		"NG": "Nigeria",
+		"NI": "Nicaragua",
+		"NL": "Netherlands",
+		"NO": "Norway",
+		"NP": "Nepal",
+		"NR": "Nauru",
+		"NT": "Neutral Zone (no longer exists)",
+		"NU": "Niue",
+		"NZ": "New Zealand",
+		"OM": "Oman",
+		"PA": "Panama",
+		"PE": "Peru",
+		"PF": "French Polynesia",
+		"PG": "Papua New Guinea",
+		"PH": "Philippines",
+		"PK": "Pakistan",
+		"PL": "Poland",
+		"PM": "St. Pierre & Miquelon",
+		"PN": "Pitcairn",
+		"PR": "Puerto Rico",
+		"PT": "Portugal",
+		"PW": "Palau",
+		"PY": "Paraguay",
+		"QA": "Qatar",
+		"RE": "Reunion",
+		"RO": "Romania",
+		"RU": "Russian Federation",
+		"RW": "Rwanda",
+		"SA": "Saudi Arabia",
+		"SB": "Solomon Islands",
+		"SC": "Seychelles",
+		"SD": "Sudan",
+		"SE": "Sweden",
+		"SG": "Singapore",
+		"SH": "St. Helena",
+		"SI": "Slovenia",
+		"SJ": "Svalbard & Jan Mayen Islands",
+		"SK": "Slovakia",
+		"SL": "Sierra Leone",
+		"SM": "San Marino",
+		"SN": "Senegal",
+		"SO": "Somalia",
+		"SR": "Suriname",
+		"ST": "Sao Tome & Principe",
+		"SU": "Union of Soviet Socialist Republics (no longer exists)",
+		"SV": "El Salvador",
+		"SY": "Syrian Arab Republic",
+		"SZ": "Swaziland",
+		"TC": "Turks & Caicos Islands",
+		"TD": "Chad",
+		"TF": "French Southern Territories",
+		"TG": "Togo",
+		"TH": "Thailand",
+		"TJ": "Tajikistan",
+		"TK": "Tokelau",
+		"TM": "Turkmenistan",
+		"TN": "Tunisia",
+		"TO": "Tonga",
+		"TP": "East Timor",
+		"TR": "Turkey",
+		"TT": "Trinidad & Tobago",
+		"TV": "Tuvalu",
+		"TW": "Taiwan, Province of China",
+		"TZ": "Tanzania, United Republic of",
+		"UA": "Ukraine",
+		"UG": "Uganda",
+		"UK": "United Kingdom",
+		"UM": "United States Minor Outlying Islands",
+		"US": "United States of America",
+		"UY": "Uruguay",
+		"UZ": "Uzbekistan",
+		"VA": "Vatican City State (Holy See)",
+		"VC": "St. Vincent & the Grenadines",
+		"VE": "Venezuela",
+		"VG": "British Virgin Islands",
+		"VI": "United States Virgin Islands",
+		"VN": "Viet Nam",
+		"VU": "Vanuatu",
+		"WF": "Wallis & Futuna Islands",
+		"WS": "Samoa",
+		"YD": "Democratic Yemen (no longer exists)",
+		"YE": "Yemen",
+		"YT": "Mayotte",
+		"YU": "Yugoslavia",
+		"ZA": "South Africa",
+		"ZM": "Zambia",
+		"ZR": "Zaire",
+		"ZW": "Zimbabwe",
+		"ZZ": "Unknown or unspecified country",
+	}
 }
--- a/logwriter.go
+++ b/logwriter.go
@@ -1,57 +1,57 @@
 package main

 import (
-    "io"
-    "errors"
-    "time"
+	"errors"
+	"io"
+	"time"
 )

 const MAX_LOG_QLEN = 128
 const QUEUE_SHUTDOWN_TIMEOUT = 500 * time.Millisecond

 type LogWriter struct {
-    writer io.Writer
-    ch chan []byte
-    done chan struct{}
+	writer io.Writer
+	ch     chan []byte
+	done   chan struct{}
 }

 func (lw *LogWriter) Write(p []byte) (int, error) {
-    if p == nil {
-        return 0, errors.New("Can't write nil byte slice")
-    }
-    buf := make([]byte, len(p))
-    copy(buf, p)
-    select {
-    case lw.ch <- buf:
-        return len(p), nil
-    default:
-        return 0, errors.New("Writer queue overflow")
-    }
+	if p == nil {
+		return 0, errors.New("Can't write nil byte slice")
+	}
+	buf := make([]byte, len(p))
+	copy(buf, p)
+	select {
+	case lw.ch <- buf:
+		return len(p), nil
+	default:
+		return 0, errors.New("Writer queue overflow")
+	}
 }

 func NewLogWriter(writer io.Writer) *LogWriter {
-    lw := &LogWriter{writer,
-                     make(chan []byte, MAX_LOG_QLEN),
-                     make(chan struct{})}
-    go lw.loop()
-    return lw
+	lw := &LogWriter{writer,
+		make(chan []byte, MAX_LOG_QLEN),
+		make(chan struct{})}
+	go lw.loop()
+	return lw
 }

 func (lw *LogWriter) loop() {
-    for p := range lw.ch {
-        if p == nil {
-            break
-        }
-        lw.writer.Write(p)
-    }
-    lw.done <- struct{}{}
+	for p := range lw.ch {
+		if p == nil {
+			break
+		}
+		lw.writer.Write(p)
+	}
+	lw.done <- struct{}{}
 }

 func (lw *LogWriter) Close() {
-    lw.ch <- nil
-    timer := time.After(QUEUE_SHUTDOWN_TIMEOUT)
-    select {
-        case <-timer:
-        case <-lw.done:
-    }
+	lw.ch <- nil
+	timer := time.After(QUEUE_SHUTDOWN_TIMEOUT)
+	select {
+	case <-timer:
+	case <-lw.done:
+	}
 }
--- a/main.go
+++ b/main.go
@@ -1,106 +1,141 @@
 package main

 import (
-    "log"
-    "os"
-    "fmt"
-    "flag"
-//    "os/signal"
-//    "syscall"
-    "time"
-    "net/http"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	//    "os/signal"
+	//    "syscall"
+	"net/http"
+	"time"
 )

 var (
-    PROTOCOL_WHITELIST map[string]bool
+	PROTOCOL_WHITELIST map[string]bool
+	version            = "undefined"
 )

 func init() {
-    PROTOCOL_WHITELIST = map[string]bool{
-        "HTTP": true,
-        "http": true,
-    }
+	PROTOCOL_WHITELIST = map[string]bool{
+		"HTTP": true,
+		"http": true,
+	}
 }

 func perror(msg string) {
-    fmt.Fprintln(os.Stderr, "")
-    fmt.Fprintln(os.Stderr, msg)
+	fmt.Fprintln(os.Stderr, "")
+	fmt.Fprintln(os.Stderr, msg)
 }

 func arg_fail(msg string) {
-    perror(msg)
-    perror("Usage:")
-    flag.PrintDefaults()
-    os.Exit(2)
+	perror(msg)
+	perror("Usage:")
+	flag.PrintDefaults()
+	os.Exit(2)
 }

 type CLIArgs struct {
-    country string
-    list_countries, list_proxies bool
-    limit uint
-    bind_address string
-    verbosity int
-    timeout, rotate time.Duration
-    proxy_type string
+	country                                 string
+	list_countries, list_proxies, use_trial bool
+	limit                                   uint
+	bind_address                            string
+	verbosity                               int
+	timeout, rotate                         time.Duration
+	proxy_type                              string
+	resolver                                string
+	force_port_field                        string
+	showVersion                             bool
 }

-
 func parse_args() CLIArgs {
-    var args CLIArgs
-    flag.StringVar(&args.country, "country", "us", "desired proxy location")
-    flag.BoolVar(&args.list_countries, "list-countries", false, "list available countries and exit")
-    flag.BoolVar(&args.list_proxies, "list-proxies", false, "output proxy list and exit")
-    flag.UintVar(&args.limit, "limit", 3, "amount of proxies in retrieved list")
-    flag.StringVar(&args.bind_address, "bind-address", "127.0.0.1:8080", "HTTP proxy listen address")
-    flag.IntVar(&args.verbosity, "verbosity", 20, "logging verbosity " +
-            "(10 - debug, 20 - info, 30 - warning, 40 - error, 50 - critical)")
-    flag.DurationVar(&args.timeout, "timeout", 10 * time.Second, "timeout for network operations")
-    flag.DurationVar(&args.rotate, "rotate", 1 * time.Hour, "rotate user ID once per given period")
-    flag.StringVar(&args.proxy_type, "proxy-type", "direct", "proxy type: direct or peer")
-    flag.Parse()
-    if args.country == "" {
-        arg_fail("Country can't be empty string.")
-    }
-    if args.list_countries && args.list_proxies {
-        arg_fail("list-countries and list-proxies flags are mutually exclusive")
-    }
-    return args
+	var args CLIArgs
+	flag.StringVar(&args.force_port_field, "force-port-field", "", "force specific port field/num (example 24232 or lum)") // would be nice to not show in help page
+	flag.StringVar(&args.country, "country", "us", "desired proxy location")
+	flag.BoolVar(&args.list_countries, "list-countries", false, "list available countries and exit")
+	flag.BoolVar(&args.list_proxies, "list-proxies", false, "output proxy list and exit")
+	flag.UintVar(&args.limit, "limit", 3, "amount of proxies in retrieved list")
+	flag.StringVar(&args.bind_address, "bind-address", "127.0.0.1:8080", "HTTP proxy listen address")
+	flag.IntVar(&args.verbosity, "verbosity", 20, "logging verbosity "+
+		"(10 - debug, 20 - info, 30 - warning, 40 - error, 50 - critical)")
+	flag.DurationVar(&args.timeout, "timeout", 10*time.Second, "timeout for network operations")
+	flag.DurationVar(&args.rotate, "rotate", 1*time.Hour, "rotate user ID once per given period")
+	flag.StringVar(&args.proxy_type, "proxy-type", "direct", "proxy type: direct or peer or lum or virt or pool") // or skip but not mentioned
+	// skip would be used something like this: `./bin/hola-proxy -proxy-type skip -force-port-field 24232 -country ua.peer` for debugging
+	flag.StringVar(&args.resolver, "resolver", "https://cloudflare-dns.com/dns-query",
+		"DNS/DoH/DoT resolver to workaround Hola blocked hosts. "+
+			"See https://github.com/ameshkov/dnslookup/ for upstream DNS URL format.")
+	flag.BoolVar(&args.use_trial, "dont-use-trial", false, "use regular ports instead of trial ports") // would be nice to not show in help page
+	flag.BoolVar(&args.showVersion, "version", false, "show program version and exit")
+	flag.Parse()
+	if args.country == "" {
+		arg_fail("Country can't be empty string.")
+	}
+	if args.proxy_type == "" {
+		arg_fail("Proxy type can't be an empty string.")
+	}
+	if args.list_countries && args.list_proxies {
+		arg_fail("list-countries and list-proxies flags are mutually exclusive")
+	}
+	return args
+}
+
+func run() int {
+	args := parse_args()
+	if args.showVersion {
+		fmt.Println(version)
+		return 0
+	}
+
+	if args.list_countries {
+		return print_countries(args.timeout)
+	}
+	if args.list_proxies {
+		return print_proxies(args.country, args.proxy_type, args.limit, args.timeout)
+	}
+
+	logWriter := NewLogWriter(os.Stderr)
+	defer logWriter.Close()
+
+	mainLogger := NewCondLogger(log.New(logWriter, "MAIN    : ",
+		log.LstdFlags|log.Lshortfile),
+		args.verbosity)
+	credLogger := NewCondLogger(log.New(logWriter, "CRED    : ",
+		log.LstdFlags|log.Lshortfile),
+		args.verbosity)
+	proxyLogger := NewCondLogger(log.New(logWriter, "PROXY   : ",
+		log.LstdFlags|log.Lshortfile),
+		args.verbosity)
+	mainLogger.Info("hola-proxy client version %s is starting...", version)
+	mainLogger.Info("Constructing fallback DNS upstream...")
+	resolver, err := NewResolver(args.resolver, args.timeout)
+	if err != nil {
+		mainLogger.Critical("Unable to instantiate DNS resolver: %v", err)
+		return 6
+	}
+	mainLogger.Info("Initializing configuration provider...")
+	auth, tunnels, err := CredService(args.rotate, args.timeout, args.country, args.proxy_type, credLogger)
+	if err != nil {
+		mainLogger.Critical("Unable to instantiate credential service: %v", err)
+		logWriter.Close()
+		return 4
+	}
+	endpoint, err := get_endpoint(tunnels, args.proxy_type, args.use_trial, args.force_port_field)
+	if err != nil {
+		mainLogger.Critical("Unable to determine proxy endpoint: %v", err)
+		logWriter.Close()
+		return 5
+	}
+	mainLogger.Info("Endpoint: %s", endpoint)
+	mainLogger.Info("Starting proxy server...")
+	handler := NewProxyHandler(endpoint, auth, resolver, proxyLogger)
+	mainLogger.Info("Init complete.")
+	err = http.ListenAndServe(args.bind_address, handler)
+	mainLogger.Critical("Server terminated with a reason: %v", err)
+	mainLogger.Info("Shutting down...")
+	return 0
 }

 func main() {
-    args := parse_args()
-    if args.list_countries {
-        os.Exit(print_countries(args.timeout))
-    }
-    if args.list_proxies {
-        os.Exit(print_proxies(args.country, args.limit, args.timeout))
-    }
-
-    logWriter := NewLogWriter(os.Stderr)
-    defer logWriter.Close()
-
-    mainLogger := NewCondLogger(log.New(logWriter, "MAIN    : ",
-                                log.LstdFlags | log.Lshortfile),
-                                args.verbosity)
-    credLogger := NewCondLogger(log.New(logWriter, "CRED    : ",
-                                log.LstdFlags | log.Lshortfile),
-                                args.verbosity)
-    proxyLogger := NewCondLogger(log.New(logWriter, "PROXY   : ",
-                                log.LstdFlags | log.Lshortfile),
-                                args.verbosity)
-    mainLogger.Info("Initializing configuration provider...")
-    auth, tunnels, err := CredService(args.rotate, args.timeout, args.country, credLogger)
-    if err != nil {
-        os.Exit(4)
-    }
-    endpoint, err := get_endpoint(tunnels, args.proxy_type)
-    if err != nil {
-        mainLogger.Critical("Unable to determine proxy endpoint: %v", err)
-        os.Exit(5)
-    }
-    mainLogger.Info("Starting proxy server...")
-    handler := NewProxyHandler(endpoint, auth, proxyLogger)
-    http.ListenAndServe(args.bind_address, handler)
-
-    mainLogger.Info("Shutting down...")
+	os.Exit(run())
 }
--- a/resolver.go
+++ b/resolver.go
@@ -0,0 +1,82 @@
+package main
+
+import (
+	"github.com/AdguardTeam/dnsproxy/upstream"
+	"github.com/miekg/dns"
+	"time"
+)
+
+type Resolver struct {
+	upstream upstream.Upstream
+}
+
+const DOT = 0x2e
+
+func NewResolver(address string, timeout time.Duration) (*Resolver, error) {
+	opts := upstream.Options{Timeout: timeout}
+	u, err := upstream.AddressToUpstream(address, opts)
+	if err != nil {
+		return nil, err
+	}
+	return &Resolver{upstream: u}, nil
+}
+
+func (r *Resolver) ResolveA(domain string) []string {
+	res := make([]string, 0)
+	if len(domain) == 0 {
+		return res
+	}
+	if domain[len(domain)-1] != DOT {
+		domain = domain + "."
+	}
+	req := dns.Msg{}
+	req.Id = dns.Id()
+	req.RecursionDesired = true
+	req.Question = []dns.Question{
+		{Name: domain, Qtype: dns.TypeA, Qclass: dns.ClassINET},
+	}
+	reply, err := r.upstream.Exchange(&req)
+	if err != nil {
+		return res
+	}
+	for _, rr := range reply.Answer {
+		if a, ok := rr.(*dns.A); ok {
+			res = append(res, a.A.String())
+		}
+	}
+	return res
+}
+
+func (r *Resolver) ResolveAAAA(domain string) []string {
+	res := make([]string, 0)
+	if len(domain) == 0 {
+		return res
+	}
+	if domain[len(domain)-1] != DOT {
+		domain = domain + "."
+	}
+	req := dns.Msg{}
+	req.Id = dns.Id()
+	req.RecursionDesired = true
+	req.Question = []dns.Question{
+		{Name: domain, Qtype: dns.TypeAAAA, Qclass: dns.ClassINET},
+	}
+	reply, err := r.upstream.Exchange(&req)
+	if err != nil {
+		return res
+	}
+	for _, rr := range reply.Answer {
+		if a, ok := rr.(*dns.AAAA); ok {
+			res = append(res, a.AAAA.String())
+		}
+	}
+	return res
+}
+
+func (r *Resolver) Resolve(domain string) []string {
+	res := r.ResolveA(domain)
+	if len(res) == 0 {
+		res = r.ResolveAAAA(domain)
+	}
+	return res
+}
--- a/snapcraft.yaml
+++ b/snapcraft.yaml
@@ -0,0 +1,27 @@
+name: hola-proxy
+version: '1.4.4'
+summary: Standalone Hola proxy client.
+description: |
+  Standalone Hola proxy client. Just run it and it'll start plain HTTP proxy server forwarding traffic via Hola proxies of your choice.
+
+confinement: strict
+base: core18
+
+parts:
+  hola-proxy:
+    plugin: go
+    source: .
+    build-packages:
+      - gcc
+    override-build:
+      make &&
+      cp bin/hola-proxy "$SNAPCRAFT_PART_INSTALL"
+    stage:
+      - hola-proxy
+
+apps:
+  hola-proxy:
+    command: hola-proxy
+    plugs:
+      - network
+      - network-bind
--- a/utils.go
+++ b/utils.go
@@ -1,112 +1,166 @@
 package main

 import (
-    "fmt"
-    "context"
-    "net"
-    "sync"
-    "io"
-    "os"
-    "time"
-    "encoding/base64"
-    "encoding/csv"
-    "errors"
-    "strings"
-    "strconv"
-    "net/http"
+	"bufio"
+	"context"
+	"encoding/base64"
+	"encoding/csv"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
 )

 func basic_auth_header(login, password string) string {
-    return "basic " + base64.StdEncoding.EncodeToString(
-        []byte(login + ":" + password))
+	return "basic " + base64.StdEncoding.EncodeToString(
+		[]byte(login+":"+password))
 }

 func proxy(ctx context.Context, left, right net.Conn) {
-    wg := sync.WaitGroup{}
-    cpy := func (dst, src net.Conn) {
-        defer wg.Done()
-        io.Copy(dst, src)
-        dst.Close()
-    }
-    wg.Add(2)
-    go cpy(left, right)
-    go cpy(right, left)
-    groupdone := make(chan struct{})
-    go func() {
-        wg.Wait()
-        groupdone <-struct{}{}
-    }()
-    select {
-    case <-ctx.Done():
-        left.Close()
-        right.Close()
-    case <-groupdone:
-        return
-    }
-    <-groupdone
-    return
+	wg := sync.WaitGroup{}
+	cpy := func(dst, src net.Conn) {
+		defer wg.Done()
+		io.Copy(dst, src)
+		dst.Close()
+	}
+	wg.Add(2)
+	go cpy(left, right)
+	go cpy(right, left)
+	groupdone := make(chan struct{})
+	go func() {
+		wg.Wait()
+		groupdone <- struct{}{}
+	}()
+	select {
+	case <-ctx.Done():
+		left.Close()
+		right.Close()
+	case <-groupdone:
+		return
+	}
+	<-groupdone
+	return
 }

 func print_countries(timeout time.Duration) int {
-    ctx, _ := context.WithTimeout(context.Background(), timeout)
-    countries, err := VPNCountries(ctx)
-    if err != nil {
-        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-        return 3
-    }
-    for _, code := range countries {
-        fmt.Printf("%v - %v\n", code, ISO3166[strings.ToUpper(code)])
-    }
-    return 0
+	var (
+		countries CountryList
+		err       error
+	)
+	tx_res, tx_err := EnsureTransaction(context.Background(), timeout, func(ctx context.Context, client *http.Client) bool {
+		countries, err = VPNCountries(ctx, client)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Transaction error: %v. Retrying with the fallback mechanism...\n", err)
+			return false
+		}
+		return true
+	})
+	if tx_err != nil {
+		fmt.Fprintf(os.Stderr, "Transaction recovery mechanism failure: %v.\n", tx_err)
+		return 4
+	}
+	if !tx_res {
+		fmt.Fprintf(os.Stderr, "All attempts failed.")
+		return 3
+	}
+	for _, code := range countries {
+		fmt.Printf("%v - %v\n", code, ISO3166[strings.ToUpper(code)])
+	}
+	return 0
 }

-func print_proxies(country string, limit uint, timeout time.Duration) int {
-    ctx, _ := context.WithTimeout(context.Background(), timeout)
-    tunnels, user_uuid, err := Tunnels(ctx, country, limit)
-    if err != nil {
-        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-        return 3
-    }
-    wr := csv.NewWriter(os.Stdout)
-    login := LOGIN_PREFIX + user_uuid
-    password := tunnels.AgentKey
-    fmt.Println("Login:", login)
-    fmt.Println("Password:", password)
-    fmt.Println("Proxy-Authorization:",
-                basic_auth_header(login, password))
-    fmt.Println("")
-    wr.Write([]string{"Host", "IP address", "Direct port", "Peer port", "Vendor"})
-    for host, ip := range tunnels.IPList {
-        if (PROTOCOL_WHITELIST[tunnels.Protocol[host]]) {
-            wr.Write([]string{host,
-                              ip,
-                              strconv.FormatUint(uint64(tunnels.Port.Direct), 10),
-                              strconv.FormatUint(uint64(tunnels.Port.Peer), 10),
-                              tunnels.Vendor[host]})
-        }
-    }
-    wr.Flush()
-    return 0
+func print_proxies(country string, proxy_type string, limit uint, timeout time.Duration) int {
+	var (
+		tunnels   *ZGetTunnelsResponse
+		user_uuid string
+		err       error
+	)
+	tx_res, tx_err := EnsureTransaction(context.Background(), timeout, func(ctx context.Context, client *http.Client) bool {
+		tunnels, user_uuid, err = Tunnels(ctx, client, country, proxy_type, limit)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Transaction error: %v. Retrying with the fallback mechanism...\n", err)
+			return false
+		}
+		return true
+	})
+	if tx_err != nil {
+		fmt.Fprintf(os.Stderr, "Transaction recovery mechanism failure: %v.\n", tx_err)
+		return 4
+	}
+	if !tx_res {
+		fmt.Fprintf(os.Stderr, "All attempts failed.")
+		return 3
+	}
+	wr := csv.NewWriter(os.Stdout)
+	login := LOGIN_PREFIX + user_uuid
+	password := tunnels.AgentKey
+	fmt.Println("Login:", login)
+	fmt.Println("Password:", password)
+	fmt.Println("Proxy-Authorization:",
+		basic_auth_header(login, password))
+	fmt.Println("")
+	wr.Write([]string{"host", "ip_address", "direct", "peer", "hola", "trial", "trial_peer", "vendor"})
+	for host, ip := range tunnels.IPList {
+		if PROTOCOL_WHITELIST[tunnels.Protocol[host]] {
+			wr.Write([]string{host,
+				ip,
+				strconv.FormatUint(uint64(tunnels.Port.Direct), 10),
+				strconv.FormatUint(uint64(tunnels.Port.Peer), 10),
+				strconv.FormatUint(uint64(tunnels.Port.Hola), 10),
+				strconv.FormatUint(uint64(tunnels.Port.Trial), 10),
+				strconv.FormatUint(uint64(tunnels.Port.TrialPeer), 10),
+				tunnels.Vendor[host]})
+		}
+	}
+	wr.Flush()
+	return 0
 }

-func get_endpoint(tunnels *ZGetTunnelsResponse, typ string) (string, error) {
-    var hostname string
-    for k, _ := range tunnels.IPList {
-        hostname = k
-        break
-    }
-    if hostname == "" {
-        return "", errors.New("No tunnels found in API response")
-    }
-    var port uint16
-    if typ == "direct" {
-        port = tunnels.Port.Direct
-    } else if typ == "peer" {
-        port = tunnels.Port.Peer
-    } else {
-        return "", errors.New("Unsupported port type")
-    }
-    return net.JoinHostPort(hostname, strconv.FormatUint(uint64(port), 10)), nil
+func get_endpoint(tunnels *ZGetTunnelsResponse, typ string, trial bool, force_port_field string) (string, error) {
+	var hostname string
+	for k := range tunnels.IPList {
+		hostname = k
+		break
+	}
+	if hostname == "" {
+		return "", errors.New("No tunnels found in API response")
+	}
+
+	var port uint16
+	if force_port_field != "" {
+		port2, err := strconv.ParseUint(force_port_field, 0, 16)
+		if err == nil {
+			port = (uint16)(port2)
+			typ = "skip"
+		} else {
+			typ = force_port_field
+		}
+	}
+	if typ != "skip" {
+		if typ == "direct" || typ == "lum" || typ == "pool" || typ == "virt" {
+			if !trial {
+				port = tunnels.Port.Trial
+			} else {
+				port = tunnels.Port.Direct
+			}
+		} else if typ == "peer" {
+			if !trial {
+				port = tunnels.Port.TrialPeer
+			} else {
+				port = tunnels.Port.Peer
+			}
+		} else {
+			return "", errors.New("Unsupported port type")
+		}
+	}
+	return net.JoinHostPort(hostname, strconv.FormatUint(uint64(port), 10)), nil
 }

 // Hop-by-hop headers. These are removed when sent to the backend.
@@ -115,6 +169,7 @@ var hopHeaders = []string{
 	"Connection",
 	"Keep-Alive",
 	"Proxy-Authenticate",
+	"Proxy-Connection",
 	"Te", // canonicalized version of "TE"
 	"Trailers",
 	"Transfer-Encoding",
@@ -135,3 +190,94 @@ func delHopHeaders(header http.Header) {
 	}
 }

+func hijack(hijackable interface{}) (net.Conn, *bufio.ReadWriter, error) {
+	hj, ok := hijackable.(http.Hijacker)
+	if !ok {
+		return nil, nil, errors.New("Connection doesn't support hijacking")
+	}
+	conn, rw, err := hj.Hijack()
+	if err != nil {
+		return nil, nil, err
+	}
+	var emptytime time.Time
+	err = conn.SetDeadline(emptytime)
+	if err != nil {
+		conn.Close()
+		return nil, nil, err
+	}
+	return conn, rw, nil
+}
+
+func rewriteConnectReq(req *http.Request, resolver *Resolver) error {
+	origHost := req.Host
+	origAddr, origPort, err := net.SplitHostPort(origHost)
+	if err == nil {
+		origHost = origAddr
+	}
+	addrs := resolver.Resolve(origHost)
+	if len(addrs) == 0 {
+		return errors.New("Can't resolve host")
+	}
+	if origPort == "" {
+		req.URL.Host = addrs[0]
+		req.Host = addrs[0]
+		req.RequestURI = addrs[0]
+	} else {
+		req.URL.Host = net.JoinHostPort(addrs[0], origPort)
+		req.Host = net.JoinHostPort(addrs[0], origPort)
+		req.RequestURI = net.JoinHostPort(addrs[0], origPort)
+	}
+	return nil
+}
+
+func rewriteReq(req *http.Request, resolver *Resolver) error {
+	origHost := req.URL.Host
+	origAddr, origPort, err := net.SplitHostPort(origHost)
+	if err == nil {
+		origHost = origAddr
+	}
+	addrs := resolver.Resolve(origHost)
+	if len(addrs) == 0 {
+		return errors.New("Can't resolve host")
+	}
+	if origPort == "" {
+		req.URL.Host = addrs[0]
+		req.Host = addrs[0]
+	} else {
+		req.URL.Host = net.JoinHostPort(addrs[0], origPort)
+		req.Host = net.JoinHostPort(addrs[0], origPort)
+	}
+	req.Header.Set("Host", origHost)
+	return nil
+}
+
+func makeConnReq(uri string, resolver *Resolver) (*http.Request, error) {
+	parsed_url, err := url.Parse(uri)
+	if err != nil {
+		return nil, err
+	}
+	origAddr, origPort, err := net.SplitHostPort(parsed_url.Host)
+	if err != nil {
+		origAddr = parsed_url.Host
+		switch strings.ToLower(parsed_url.Scheme) {
+		case "https":
+			origPort = "443"
+		case "http":
+			origPort = "80"
+		default:
+			return nil, errors.New("Unknown scheme")
+		}
+	}
+	addrs := resolver.Resolve(origAddr)
+	if len(addrs) == 0 {
+		return nil, errors.New("Can't resolve host")
+	}
+	new_uri := net.JoinHostPort(addrs[0], origPort)
+	req, err := http.NewRequest("CONNECT", "http://"+new_uri, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.RequestURI = new_uri
+	req.Host = new_uri
+	return req, nil
+}
Author	SHA1	Message	Date
Vladislav Yarmak	528e2b2a71	bump snap version	2021-03-15 04:13:04 +02:00
Snawoot	0a473f9662	Merge pull request #32 from Snawoot/fallback feat: Hola API communication failover	2021-03-15 04:12:15 +02:00
Vladislav Yarmak	17860682be	do not resolve fallback agent IP addr, use provided in config	2021-03-15 04:07:03 +02:00
Vladislav Yarmak	1f6c87a797	fix typos	2021-03-15 02:21:23 +02:00
Vladislav Yarmak	72beef10c9	feat: Hola API communication failover	2021-03-15 02:13:42 +02:00
Vladislav Yarmak	ead89d5245	snap: remove unnecessary go-importpath	2021-03-13 06:32:48 +02:00
Vladislav Yarmak	6edd098c82	embed version into snap image	2021-03-13 06:30:34 +02:00
Vladislav Yarmak	752d2ba789	fix dockerfile version embedding	2021-03-13 05:28:49 +02:00
Snawoot	311d1ad74d	Merge pull request #30 from Snawoot/docker_builds embed version into docker image	2021-03-13 05:14:54 +02:00
Vladislav Yarmak	6ac04587cb	embed version into docker image	2021-03-13 05:14:19 +02:00
Vladislav Yarmak	8c3538ab4c	bump snap version	2021-03-13 04:42:20 +02:00
Snawoot	ff3c0f68fc	Merge pull request #29 from Snawoot/versioning embed version into binary	2021-03-13 04:35:35 +02:00
Vladislav Yarmak	4f72e317fc	embed version into local install and local run as well	2021-03-13 04:34:24 +02:00
Vladislav Yarmak	4ddd1284fb	embed version into binary	2021-03-13 04:23:36 +02:00
Snawoot	4fe6636003	Merge pull request #27 from rany2/master Don't repeat response code twice	2021-03-13 00:06:37 +02:00
Snawoot	b5ac6d38e5	Merge pull request #28 from Snawoot/fix_status_log fix status logging on hola api error	2021-03-13 00:05:44 +02:00
Vladislav Yarmak	0c377308c0	fix status logging on hola api error	2021-03-13 00:04:57 +02:00
rany	3b21036b20	Don't repeat response code twice	2021-03-12 23:28:35 +02:00
Vladislav Yarmak	683bc5f1ec	bump snap version	2021-03-12 22:30:29 +02:00
Snawoot	be2e4e5420	Merge pull request #26 from Snawoot/holaapi_req_2xx hola: expect only 2xx responses	2021-03-12 22:29:46 +02:00
Vladislav Yarmak	95adb40377	hola: expect only 2xx responses	2021-03-12 22:27:31 +02:00
Snawoot	6ced446e68	Merge pull request #25 from Snawoot/detect_block Detect block	2021-03-12 21:01:12 +02:00
Vladislav Yarmak	9c15f5eda9	add few helper targets to makefile	2021-03-12 20:59:26 +02:00
Vladislav Yarmak	afe3e3f732	detect ban in bg_init response	2021-03-12 20:58:30 +02:00
Vladislav Yarmak	e67b30a116	bump snap version	2021-03-08 01:08:17 +02:00
Snawoot	edc367f194	Merge pull request #22 from rany2/master Fix nonsense help page	2021-03-08 01:07:48 +02:00
rany	ed77f8a254	help page update in README	2021-03-08 00:19:58 +02:00
rany	45977423f6	Fix -dont-use-trial	2021-03-08 00:18:53 +02:00
rany	64c90af10b	change wording in readme	2021-03-08 00:15:55 +02:00
rany	c3180ad245	change wording	2021-03-08 00:15:12 +02:00
rany	0052dea171	Fix nonsense help page	2021-03-08 00:13:33 +02:00
Vladislav Yarmak	e89c83ce05	bump snap version	2021-03-08 00:08:11 +02:00
Snawoot	2f38f5b4d1	Merge pull request #20 from rany2/master Use trial ports by default and add new virt proxy-type	2021-03-08 00:06:02 +02:00
rany	a880f1d9e3	Remove localhost shortcut	2021-03-07 22:34:38 +02:00
rany	4c10fac620	simplify bind-address to accept port and make it listen to 127.0.0.1	2021-03-07 21:03:57 +02:00
rany	92f28d996a	Add a few more flags for debugging	2021-03-07 20:54:47 +02:00
rany	a106ef9e56	Add new virt proxy type (unknown use but used by extension for some sites) + gofmt everything	2021-03-07 19:57:46 +02:00
Vladislav Yarmak	12b05ac0df	bump snap version	2021-03-07 13:32:11 +02:00
Snawoot	d798373e66	Merge pull request #18 from rany2/master Add new proxy-type pool	2021-03-07 13:31:19 +02:00
rany	1d8499dd2e	Merge branch 'master' of https://github.com/Snawoot/hola-proxy	2021-03-07 12:52:30 +02:00
rany	e2c9711d73	Add new proxy type pool	2021-03-07 12:47:04 +02:00
rany	5246eff0f5	Add text file with all hola blocked domains	2021-03-07 01:54:50 +02:00
Vladislav Yarmak	45c6521777	bump snap version	2021-03-06 22:27:02 +02:00
Snawoot	db109ce9ad	Merge pull request #16 from rany2/master Fix #15	2021-03-06 22:26:05 +02:00
rany	16192a36ba	Fix #15	2021-03-06 22:09:39 +02:00
Vladislav Yarmak	d75ab999c8	bump snap version	2021-03-06 21:16:37 +02:00
Snawoot	a95a6519aa	Merge pull request #14 from rany2/master Fix #13 and enhancements	2021-03-06 21:00:42 +02:00
rany	5774d898d2	update country list from readme	2021-03-06 20:13:43 +02:00
rany	8a3b18e784	update readme	2021-03-06 20:13:01 +02:00
rany	3ebfea6b86	switch back default port	2021-03-06 20:09:56 +02:00
rany	92b7a509e9	remove binary	2021-03-06 20:07:11 +02:00
rany	d4b8306cd4	Fix #13 and enhacements * Add `-use-trial` to use trial ports. * Mention Hola and Trial ports in `-list-proxies` * Add GB to `-list-countries` if UK is present. This is what extension does. * Add `lum` proxy-type to use residential ips * Change `peer` and `lum` behavior to also modify the country to `country_code`.peer and `country_code`.pool_lum_`country_code`._shared. This lets them work properly * Above means that `list-proxies` behavior will change based on `-proxy-type` now(The port isn't the only thing that matters)	2021-03-06 20:03:01 +02:00
Vladislav Yarmak	335894d533	add IPFS mirror	2020-10-24 20:23:54 +03:00
Vladislav Yarmak	d95706046d	update readme	2020-08-10 00:50:26 +03:00
Vladislav Yarmak	6fecb99728	add endpoint info to log	2020-05-18 02:00:56 +03:00
Snawoot	0d0cbca13e	Merge pull request #3 from Snawoot/readme_upd doc update	2020-04-20 22:37:57 +03:00
Vladislav Yarmak	3462113454	doc update	2020-04-20 22:34:58 +03:00
Vladislav Yarmak	db9499a936	snap: add required plugs	2020-04-20 22:18:34 +03:00
Vladislav Yarmak	1052329228	add snap build spec	2020-04-20 21:29:45 +03:00
Vladislav Yarmak	94addea5d4	single-layer docker image	2020-04-18 14:04:43 +03:00
Vladislav Yarmak	56a10f2a32	fix docker example	2020-04-18 12:44:40 +03:00
Snawoot	801178a7de	Merge pull request #2 from Snawoot/docker add docker support	2020-04-18 12:33:59 +03:00
Vladislav Yarmak	6d627de3d7	add docker support	2020-04-18 12:30:26 +03:00
Vladislav Yarmak	1a9f547cfe	minor improvements	2020-04-14 11:45:03 +03:00
Vladislav Yarmak	1984bb06ee	update docs	2020-04-14 00:11:04 +03:00
Snawoot	012d6fbe16	Merge pull request #1 from Snawoot/autoresolve workaround hola blocked hosts	2020-04-13 23:48:51 +03:00
Vladislav Yarmak	73cdcfb701	polish	2020-04-13 23:48:31 +03:00
Vladislav Yarmak	c626c7cdcc	workaround hola blocked hosts	2020-04-13 23:39:58 +03:00
Vladislav Yarmak	f8129259ba	print shutdown reason	2020-03-27 01:39:58 +02:00