diff --git a/AndroidLibV2rayLite/.travis.yml b/AndroidLibV2rayLite/.travis.yml new file mode 100644 index 00000000..c3beb7db --- /dev/null +++ b/AndroidLibV2rayLite/.travis.yml @@ -0,0 +1,26 @@ +sudo: required +language: go +go: + - "1.12" +go_import_path: github.com/2dust/AndroidLibV2rayLite +git: + depth: 5 +addons: + apt: + update: true +before_script: +- sudo ntpdate -u time.google.com +- date +- make all +- make downloadGoMobile +script: +- make BuildMobile +after_success: +deploy: + provider: releases + api_key: ${GH_TOKEN} + file: + - libv2ray.aar + skip_cleanup: true + on: + tags: true diff --git a/AndroidLibV2rayLite/CoreI/Status.go b/AndroidLibV2rayLite/CoreI/Status.go new file mode 100644 index 00000000..a5d4b942 --- /dev/null +++ b/AndroidLibV2rayLite/CoreI/Status.go @@ -0,0 +1,63 @@ +package CoreI + +import ( + v2core "v2ray.com/core" +) + +type Status struct { + IsRunning bool + PackageName string + + Vpoint v2core.Server +} + +func CheckVersion() int { + return 20 +} + +func (v *Status) GetDataDir() string { + return v.PackageName +} + +func (v *Status) GetApp(name string) string { + return v.PackageName + name +} + +func (v *Status) GetTun2socksArgs(localDNS bool, enableIPv6 bool) (ret []string) { + ret = []string{"--netif-ipaddr", + "26.26.26.2", + "--netif-netmask", + "255.255.255.252", + "--socks-server-addr", + "127.0.0.1:10808", + "--tunmtu", + "1500", + "--loglevel", + "notice", + "--enable-udprelay", + "--sock-path", + v.GetDataDir() + "sock_path", + } + + if enableIPv6 { + ret = append(ret, "--netif-ip6addr", "da26:2626::2") + } + + if localDNS { + ret = append(ret, "--dnsgw", "127.0.0.1:10807") + } + + return +} + +func (v *Status) GetVPNSetupArg(localDNS bool, enableIPv6 bool) (ret string) { + ret = "m,1500 a,26.26.26.1,30 r,0.0.0.0,0" + + if enableIPv6 { + ret += " a,da26:2626::1,126 r,::,0" + } + if localDNS { + ret += " d,26.26.26.2" + } + return +} diff --git a/AndroidLibV2rayLite/Makefile b/AndroidLibV2rayLite/Makefile new file mode 100644 index 00000000..f4a4ec68 --- /dev/null +++ b/AndroidLibV2rayLite/Makefile @@ -0,0 +1,34 @@ +pb: + go get -u github.com/golang/protobuf/protoc-gen-go + @echo "pb Start" +asset: + bash gen_assets.sh download + mkdir assets + cp -v data/*.dat assets/ + # cd assets;curl https://raw.githubusercontent.com/2dust/AndroidLibV2rayLite/master/data/geosite.dat > geosite.dat + # cd assets;curl https://raw.githubusercontent.com/2dust/AndroidLibV2rayLite/master/data/geoip.dat > geoip.dat + +shippedBinary: + cd shippedBinarys; $(MAKE) shippedBinary + +fetchDep: + -go get github.com/2dust/AndroidLibV2rayLite + go get github.com/2dust/AndroidLibV2rayLite + +ANDROID_HOME=$(HOME)/android-sdk-linux +export ANDROID_HOME +PATH:=$(PATH):$(GOPATH)/bin +export PATH +downloadGoMobile: + go get golang.org/x/mobile/cmd/... + sudo apt-get install -qq libstdc++6:i386 lib32z1 expect + cd ~ ;curl -L https://raw.githubusercontent.com/2dust/AndroidLibV2rayLite/master/ubuntu-cli-install-android-sdk.sh | sudo bash - > /dev/null + ls ~ + ls ~/android-sdk-linux/ + gomobile init ;gomobile bind -v -tags json github.com/2dust/AndroidLibV2rayLite + +BuildMobile: + @echo Stub + +all: asset pb shippedBinary fetchDep + @echo DONE diff --git a/AndroidLibV2rayLite/Process/Escort/escort.go b/AndroidLibV2rayLite/Process/Escort/escort.go new file mode 100644 index 00000000..69c9430a --- /dev/null +++ b/AndroidLibV2rayLite/Process/Escort/escort.go @@ -0,0 +1,87 @@ +package Escort + +import ( + "os" + "os/exec" + "time" + + "log" + + "github.com/2dust/AndroidLibV2rayLite/CoreI" +) + +func (v *Escorting) EscortRun(proc string, pt []string, additionalEnv string, sendFd func() int) { + log.Println(proc, pt) + count := 0 + for count <= 42 { + cmd := exec.Command(proc, pt...) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + + if len(additionalEnv) > 0 { + //additionalEnv := "FOO=bar" + newEnv := append(os.Environ(), additionalEnv) + cmd.Env = newEnv + } + + if err := cmd.Start(); err != nil { + log.Println("EscortRun cmd.Start err", err) + goto CMDERROR + } + + if v.escortProcess == nil { + log.Println("EscortRun v.escortProcess nil") + break + } + + *v.escortProcess = append(*v.escortProcess, cmd.Process) + log.Println("EscortRun Waiting....") + + if count > 0 { + go func() { + time.Sleep(time.Second) + sendFd() + }() + } + + if err := cmd.Wait(); err != nil { + log.Println("EscortRun cmd.Wait err:", err) + } + + CMDERROR: + if v.Status.IsRunning { + log.Println("EscortRun Unexpected Exit, Restart now.") + count++ + } else { + log.Println("EscortRun Exit") + break + } + } +} + +func (v *Escorting) EscortingUp() { + if v.escortProcess != nil { + return + } + v.escortProcess = new([](*os.Process)) +} + +func (v *Escorting) EscortingDown() { + if v.escortProcess == nil { + return + } + + log.Println("EscortingDown() Killing all escorted process ") + for _, pr := range *v.escortProcess { + pr.Kill() + if _, err := pr.Wait(); err != nil { + log.Println("EscortingDown pr.Wait err:", err) + } + } + v.escortProcess = nil +} + +type Escorting struct { + escortProcess *[](*os.Process) + Status *CoreI.Status +} diff --git a/AndroidLibV2rayLite/README.md b/AndroidLibV2rayLite/README.md new file mode 100644 index 00000000..1c1962bc --- /dev/null +++ b/AndroidLibV2rayLite/README.md @@ -0,0 +1 @@ +# AndroidLibV2rayLite diff --git a/AndroidLibV2rayLite/VPN/vpnservice_support.go b/AndroidLibV2rayLite/VPN/vpnservice_support.go new file mode 100644 index 00000000..f7456cac --- /dev/null +++ b/AndroidLibV2rayLite/VPN/vpnservice_support.go @@ -0,0 +1,279 @@ +package VPN + +import ( + "context" + "errors" + "fmt" + "log" + "net" + "os" + "strings" + "sync" + "time" + + "golang.org/x/sys/unix" + v2net "v2ray.com/core/common/net" + v2internet "v2ray.com/core/transport/internet" +) + +type protectSet interface { + Protect(int) int +} + +type resolved struct { + domain string + IPs []net.IP + Port int + ipIdx uint8 + ipLock sync.Mutex + lastSwitched time.Time +} + +// NextIP switch to another resolved result. +// there still be race-condition here if multiple err concurently occured +// may cause idx keep switching, +// but that's an outside error can hardly handled here +func (r *resolved) NextIP() { + r.ipLock.Lock() + defer r.ipLock.Unlock() + + if len(r.IPs) > 1 { + + // throttle, don't switch too quickly + now := time.Now() + if now.Sub(r.lastSwitched) < time.Second*5 { + log.Println("switch too quickly") + return + } + r.lastSwitched = now + r.ipIdx++ + + } else { + return + } + + if r.ipIdx >= uint8(len(r.IPs)) { + r.ipIdx = 0 + } + + cur := r.currentIP() + log.Printf("switched to next IP: %s", cur) +} + +func (r *resolved) currentIP() net.IP { + if len(r.IPs) > 0 { + return r.IPs[r.ipIdx] + } + + return nil +} + +// NewPreotectedDialer ... +func NewPreotectedDialer(p protectSet) *ProtectedDialer { + d := &ProtectedDialer{ + // prefer native lookup on Android + resolver: &net.Resolver{PreferGo: false}, + protectSet: p, + } + return d +} + +// ProtectedDialer ... +type ProtectedDialer struct { + currentServer string + resolveChan chan struct{} + + vServer *resolved + resolver *net.Resolver + + protectSet +} + +func (d *ProtectedDialer) IsVServerReady() bool { + return (d.vServer != nil) +} + +func (d *ProtectedDialer) PrepareResolveChan() { + d.resolveChan = make(chan struct{}) +} + +func (d *ProtectedDialer) ResolveChan() <-chan struct{} { + return d.resolveChan +} + +// simplicated version of golang: internetAddrList in src/net/ipsock.go +func (d *ProtectedDialer) lookupAddr(addr string) (*resolved, error) { + + var ( + err error + host, port string + portnum int + ) + + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + + if host, port, err = net.SplitHostPort(addr); err != nil { + log.Printf("PrepareDomain SplitHostPort Err: %v", err) + return nil, err + } + + if portnum, err = d.resolver.LookupPort(ctx, "tcp", port); err != nil { + log.Printf("PrepareDomain LookupPort Err: %v", err) + return nil, err + } + + addrs, err := d.resolver.LookupIPAddr(ctx, host) + if err != nil { + return nil, err + } + if len(addrs) == 0 { + return nil, fmt.Errorf("domain %s Failed to resolve", addr) + } + + IPs := make([]net.IP, len(addrs)) + for i, ia := range addrs { + IPs[i] = ia.IP + } + + rs := &resolved{ + domain: host, + IPs: IPs, + Port: portnum, + } + + return rs, nil +} + +// PrepareDomain caches direct v2ray server host +func (d *ProtectedDialer) PrepareDomain(domainName string, closeCh <-chan struct{}) { + log.Printf("Preparing Domain: %s", domainName) + d.currentServer = domainName + + defer close(d.resolveChan) + maxRetry := 10 + for { + if maxRetry == 0 { + log.Println("PrepareDomain maxRetry reached. exiting.") + return + } + + resolved, err := d.lookupAddr(domainName) + if err != nil { + maxRetry-- + log.Printf("PrepareDomain err: %v\n", err) + select { + case <-closeCh: + log.Printf("PrepareDomain exit due to v2ray closed") + return + case <-time.After(time.Second * 2): + } + continue + } + + d.vServer = resolved + log.Printf("Prepare Result:\n Domain: %s\n Port: %d\n IPs: %v\n", + resolved.domain, resolved.Port, resolved.IPs) + return + } +} + +func (d *ProtectedDialer) getFd(network v2net.Network) (fd int, err error) { + switch network { + case v2net.Network_TCP: + fd, err = unix.Socket(unix.AF_INET6, unix.SOCK_STREAM, unix.IPPROTO_TCP) + case v2net.Network_UDP: + fd, err = unix.Socket(unix.AF_INET6, unix.SOCK_DGRAM, unix.IPPROTO_UDP) + default: + err = fmt.Errorf("unknow network") + } + return +} + +// Dial exported as the protected dial method +func (d *ProtectedDialer) Dial(ctx context.Context, + src v2net.Address, dest v2net.Destination, sockopt *v2internet.SocketConfig) (net.Conn, error) { + + network := dest.Network.SystemString() + Address := dest.NetAddr() + + // v2ray server address, + // try to connect fixed IP if multiple IP parsed from domain, + // and switch to next IP if error occurred + if strings.Compare(Address, d.currentServer) == 0 { + if d.vServer == nil { + log.Println("Dial pending prepare ...", Address) + <-d.resolveChan + + // user may close connection during PrepareDomain, + // fast return release resources. + if d.vServer == nil { + return nil, fmt.Errorf("fail to prepare domain %s", d.currentServer) + } + } + + fd, err := d.getFd(dest.Network) + if err != nil { + return nil, err + } + + curIP := d.vServer.currentIP() + conn, err := d.fdConn(ctx, curIP, d.vServer.Port, fd) + if err != nil { + d.vServer.NextIP() + return nil, err + } + log.Printf("Using Prepared: %s", curIP) + return conn, nil + } + + // v2ray connecting to "domestic" servers, no caching results + log.Printf("Not Using Prepared: %s,%s", network, Address) + resolved, err := d.lookupAddr(Address) + if err != nil { + return nil, err + } + + fd, err := d.getFd(dest.Network) + if err != nil { + return nil, err + } + + // use the first resolved address. + // the result IP may vary, eg: IPv6 addrs comes first if client has ipv6 address + return d.fdConn(ctx, resolved.IPs[0], resolved.Port, fd) +} + +func (d *ProtectedDialer) fdConn(ctx context.Context, ip net.IP, port int, fd int) (net.Conn, error) { + + defer unix.Close(fd) + + // call android VPN service to "protect" the fd connecting straight out + d.Protect(fd) + + sa := &unix.SockaddrInet6{ + Port: port, + } + copy(sa.Addr[:], ip) + + if err := unix.Connect(fd, sa); err != nil { + log.Printf("fdConn unix.Connect err, Close Fd: %d Err: %v", fd, err) + return nil, err + } + + file := os.NewFile(uintptr(fd), "Socket") + if file == nil { + // returned value will be nil if fd is not a valid file descriptor + return nil, errors.New("fdConn fd invalid") + } + + defer file.Close() + //Closing conn does not affect file, and closing file does not affect conn. + conn, err := net.FileConn(file) + if err != nil { + log.Printf("fdConn FileConn Close Fd: %d Err: %v", fd, err) + return nil, err + } + + return conn, nil +} diff --git a/AndroidLibV2rayLite/VPN/vpnservice_support_test.go b/AndroidLibV2rayLite/VPN/vpnservice_support_test.go new file mode 100644 index 00000000..883f2f6e --- /dev/null +++ b/AndroidLibV2rayLite/VPN/vpnservice_support_test.go @@ -0,0 +1,151 @@ +package VPN + +import ( + "bufio" + "context" + "fmt" + "net" + "sync" + "testing" + "time" + + v2net "v2ray.com/core/common/net" +) + +type fakeSupportSet struct{} + +func (f fakeSupportSet) Protect(int) int { + return 0 +} + +func TestProtectedDialer_PrepareDomain(t *testing.T) { + type args struct { + domainName string + } + tests := []struct { + name string + args args + }{ + // TODO: Add test cases. + {"", args{"baidu.com:80"}}, + // {"", args{"cloudflare.com:443"}}, + // {"", args{"apple.com:443"}}, + // {"", args{"110.110.110.110:443"}}, + // {"", args{"[2002:1234::1]:443"}}, + } + d := NewPreotectedDialer(fakeSupportSet{}) + for _, tt := range tests { + ch := make(chan struct{}) + t.Run(tt.name, func(t *testing.T) { + go d.PrepareDomain(tt.args.domainName, ch) + + time.Sleep(time.Second) + go d.vServer.NextIP() + t.Log(d.vServer.currentIP()) + }) + } + + time.Sleep(time.Second) +} + +func TestProtectedDialer_Dial(t *testing.T) { + + tests := []struct { + name string + wantErr bool + }{ + // TODO: Add test cases. + {"baidu.com:80", false}, + {"cloudflare.com:80", false}, + {"172.16.192.11:80", true}, + // {"172.16.192.10:80", true}, + // {"[2fff:4322::1]:443", true}, + // {"[fc00::1]:443", true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ch := make(chan struct{}) + + d := NewPreotectedDialer(fakeSupportSet{}) + d.currentServer = tt.name + + go d.PrepareDomain(tt.name, ch) + + var wg sync.WaitGroup + + dial := func() { + defer wg.Done() + dest, _ := v2net.ParseDestination("tcp:" + tt.name) + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + + conn, err := d.Dial(ctx, nil, dest, nil) + if err != nil { + t.Log(err) + return + } + _host, _, _ := net.SplitHostPort(tt.name) + fmt.Fprintf(conn, fmt.Sprintf("GET / HTTP/1.1\r\nHost: %s\r\n\r\n", _host)) + status, err := bufio.NewReader(conn).ReadString('\n') + t.Logf("%#v, %#v\n", status, err) + conn.Close() + } + + for n := 0; n < 3; n++ { + wg.Add(1) + go dial() + // time.Sleep(time.Millisecond * 10) + // d.pendingMap[tt.name] = make(chan struct{}) + } + + wg.Wait() + }) + } +} + +func Test_resolved_NextIP(t *testing.T) { + type fields struct { + domain string + IPs []net.IP + Port int + } + tests := []struct { + name string + fields fields + }{ + // TODO: Add test cases. + {"test1", + fields{ + domain: "www.baidu.com", + IPs: []net.IP{ + net.ParseIP("1.2.3.4"), + net.ParseIP("4.3.2.1"), + net.ParseIP("1234::1"), + net.ParseIP("4321::1"), + }, + }}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + r := &resolved{ + domain: tt.fields.domain, + IPs: tt.fields.IPs, + Port: tt.fields.Port, + } + t.Logf("%v", r.IPs) + t.Logf("%v", r.currentIP()) + r.NextIP() + t.Logf("%v", r.currentIP()) + r.NextIP() + t.Logf("%v", r.currentIP()) + r.NextIP() + t.Logf("%v", r.currentIP()) + time.Sleep(3 * time.Second) + r.NextIP() + t.Logf("%v", r.currentIP()) + time.Sleep(5 * time.Second) + r.NextIP() + t.Logf("%v", r.currentIP()) + }) + } +} diff --git a/AndroidLibV2rayLite/compile-tun2socks.sh b/AndroidLibV2rayLite/compile-tun2socks.sh new file mode 100644 index 00000000..ef0fdbe6 --- /dev/null +++ b/AndroidLibV2rayLite/compile-tun2socks.sh @@ -0,0 +1,47 @@ +#!/bin/bash + +set -o errexit +set -o pipefail +set -o nounset + +# Set magic variables for current file & dir +__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +__file="${__dir}/$(basename "${BASH_SOURCE[0]}")" +__base="$(basename ${__file} .sh)" + +if [[ ! -d $NDK_HOME ]]; then + echo "Android NDK: NDK_HOME not found. please set env \$NDK_HOME" + exit 1 +fi + +TMPDIR=$(mktemp -d) +clear_tmp () { + rm -rf $TMPDIR +} + +trap 'echo -e "Aborted, error $? in command: $BASH_COMMAND"; trap ERR; clear_tmp; exit 1' ERR INT +install -m644 $__dir/tun2socks.mk $TMPDIR/ + +pushd $TMPDIR +git clone --depth=1 https://github.com/shadowsocks/badvpn.git +git clone --depth=1 https://github.com/shadowsocks/libancillary.git +$NDK_HOME/ndk-build \ + NDK_PROJECT_PATH=. \ + APP_BUILD_SCRIPT=./tun2socks.mk \ + APP_ABI=all \ + APP_PLATFORM=android-19 \ + NDK_LIBS_OUT=$TMPDIR/libs \ + NDK_OUT=$TMPDIR/tmp \ + APP_SHORT_COMMANDS=false LOCAL_SHORT_COMMANDS=false -B -j4 + +install -v -m755 libs/armeabi-v7a/tun2socks $__dir/shippedBinarys/ArchDep/arm/ +install -v -m755 libs/arm64-v8a/tun2socks $__dir/shippedBinarys/ArchDep/arm64/ +install -v -m755 libs/x86/tun2socks $__dir/shippedBinarys/ArchDep/386/ +install -v -m755 libs/x86_64/tun2socks $__dir/shippedBinarys/ArchDep/amd64/ +popd + +pushd $__dir/shippedBinarys +make clean && make shippedBinary +popd + +rm -rf $TMPDIR \ No newline at end of file diff --git a/AndroidLibV2rayLite/gen_assets.sh b/AndroidLibV2rayLite/gen_assets.sh new file mode 100644 index 00000000..3a102fa2 --- /dev/null +++ b/AndroidLibV2rayLite/gen_assets.sh @@ -0,0 +1,81 @@ +#!/bin/bash + +set -o errexit +set -o pipefail +set -o nounset + +# Set magic variables for current file & dir +__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +__file="${__dir}/$(basename "${BASH_SOURCE[0]}")" +__base="$(basename ${__file} .sh)" + + +DATADIR=${__dir}/data + +compile_dat () { + local TMPDIR=$(mktemp -d) + + trap 'echo -e "Aborted, error $? in command: $BASH_COMMAND"; rm -rf $TMPDIR; trap ERR; exit 1' ERR + + local GEOSITE=${GOPATH}/src/github.com/v2ray/domain-list-community + if [[ -d ${GEOSITE} ]]; then + cd ${GEOSITE} && git pull + else + mkdir -p ${GEOSITE} + cd ${GEOSITE} && git clone https://github.com/v2ray/domain-list-community.git . + fi + go run main.go + + if [[ -e dlc.dat ]]; then + rm -f $DATADIR/geosite.dat + mv dlc.dat $DATADIR/geosite.dat + echo "----------> geosite.dat updated." + else + echo "----------> geosite.dat failed to update." + fi + + + if [[ ! -x $GOPATH/bin/geoip ]]; then + go get -v -u github.com/v2ray/geoip + fi + + cd $TMPDIR + curl -L -O http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country-CSV.zip + unzip -q GeoLite2-Country-CSV.zip + mkdir geoip && find . -name '*.csv' -exec mv -t ./geoip {} + + $GOPATH/bin/geoip \ + --country=./geoip/GeoLite2-Country-Locations-en.csv \ + --ipv4=./geoip/GeoLite2-Country-Blocks-IPv4.csv \ + --ipv6=./geoip/GeoLite2-Country-Blocks-IPv6.csv + + if [[ -e geoip.dat ]]; then + rm -f $DATADIR/geoip.dat + mv ./geoip.dat $DATADIR/geoip.dat + echo "----------> geoip.dat updated." + else + echo "----------> geoip.dat failed to update." + fi + trap ERR + return 0 +} + + +download_dat () { + wget -qO - https://api.github.com/repos/v2ray/geoip/releases/latest \ + | grep browser_download_url | cut -d '"' -f 4 \ + | wget -i - -O $DATADIR/geoip.dat + + wget -qO - https://api.github.com/repos/v2ray/domain-list-community/releases/latest \ + | grep browser_download_url | cut -d '"' -f 4 \ + | wget -i - -O $DATADIR/geosite.dat +} + +ACTION="${1:-}" +if [[ -z $ACTION ]]; then + ACTION=download +fi + +case $ACTION in + "download") download_dat;; + "compile") compile_dat;; +esac diff --git a/AndroidLibV2rayLite/interact.go b/AndroidLibV2rayLite/interact.go new file mode 100644 index 00000000..b15df2dc --- /dev/null +++ b/AndroidLibV2rayLite/interact.go @@ -0,0 +1,255 @@ +package libv2ray + +import ( + "fmt" + "io" + "log" + "os" + "strings" + "sync" + + "github.com/2dust/AndroidLibV2rayLite/CoreI" + "github.com/2dust/AndroidLibV2rayLite/Process/Escort" + "github.com/2dust/AndroidLibV2rayLite/VPN" + "github.com/2dust/AndroidLibV2rayLite/shippedBinarys" + mobasset "golang.org/x/mobile/asset" + + v2core "v2ray.com/core" + v2filesystem "v2ray.com/core/common/platform/filesystem" + v2stats "v2ray.com/core/features/stats" + v2serial "v2ray.com/core/infra/conf/serial" + _ "v2ray.com/core/main/distro/all" + v2internet "v2ray.com/core/transport/internet" + + v2applog "v2ray.com/core/app/log" + v2commlog "v2ray.com/core/common/log" +) + +const ( + v2Assert = "v2ray.location.asset" + assetperfix = "/dev/libv2rayfs0/asset" +) + +/*V2RayPoint V2Ray Point Server +This is territory of Go, so no getter and setters! +*/ +type V2RayPoint struct { + SupportSet V2RayVPNServiceSupportsSet + statsManager v2stats.Manager + + dialer *VPN.ProtectedDialer + status *CoreI.Status + escorter *Escort.Escorting + v2rayOP *sync.Mutex + closeChan chan struct{} + + PackageName string + DomainName string + ConfigureFileContent string + EnableLocalDNS bool + ForwardIpv6 bool +} + +/*V2RayVPNServiceSupportsSet To support Android VPN mode*/ +type V2RayVPNServiceSupportsSet interface { + Setup(Conf string) int + Prepare() int + Shutdown() int + Protect(int) int + OnEmitStatus(int, string) int + SendFd() int +} + +/*RunLoop Run V2Ray main loop + */ +func (v *V2RayPoint) RunLoop() (err error) { + v.v2rayOP.Lock() + defer v.v2rayOP.Unlock() + //Construct Context + v.status.PackageName = v.PackageName + + if !v.status.IsRunning { + v.closeChan = make(chan struct{}) + v.dialer.PrepareResolveChan() + go v.dialer.PrepareDomain(v.DomainName, v.closeChan) + go func() { + select { + // wait until resolved + case <-v.dialer.ResolveChan(): + // shutdown VPNService if server name can not reolved + if !v.dialer.IsVServerReady() { + log.Println("vServer cannot resolved, shutdown") + v.StopLoop() + v.SupportSet.Shutdown() + } + + // stop waiting if manually closed + case <-v.closeChan: + } + }() + + err = v.pointloop() + } + return +} + +/*StopLoop Stop V2Ray main loop + */ +func (v *V2RayPoint) StopLoop() (err error) { + v.v2rayOP.Lock() + defer v.v2rayOP.Unlock() + if v.status.IsRunning { + close(v.closeChan) + v.shutdownInit() + v.SupportSet.OnEmitStatus(0, "Closed") + } + return +} + +//Delegate Funcation +func (v *V2RayPoint) GetIsRunning() bool { + return v.status.IsRunning +} + +//Delegate Funcation +func (v V2RayPoint) QueryStats(tag string, direct string) int64 { + if v.statsManager == nil { + return 0 + } + counter := v.statsManager.GetCounter(fmt.Sprintf("inbound>>>%s>>>traffic>>>%s", tag, direct)) + if counter == nil { + return 0 + } + return counter.Set(0) +} + +func (v *V2RayPoint) shutdownInit() { + v.status.IsRunning = false + v.status.Vpoint.Close() + v.status.Vpoint = nil + v.statsManager = nil + v.escorter.EscortingDown() +} + +func (v *V2RayPoint) pointloop() error { + if err := v.runTun2socks(); err != nil { + log.Println(err) + return err + } + + log.Printf("EnableLocalDNS: %v\nForwardIpv6: %v\nDomainName: %s", + v.EnableLocalDNS, + v.ForwardIpv6, + v.DomainName) + + log.Println("loading v2ray config") + config, err := v2serial.LoadJSONConfig(strings.NewReader(v.ConfigureFileContent)) + if err != nil { + log.Println(err) + return err + } + + log.Println("new v2ray core") + inst, err := v2core.New(config) + if err != nil { + log.Println(err) + return err + } + v.status.Vpoint = inst + v.statsManager = inst.GetFeature(v2stats.ManagerType()).(v2stats.Manager) + + log.Println("start v2ray core") + v.status.IsRunning = true + if err := v.status.Vpoint.Start(); err != nil { + v.status.IsRunning = false + log.Println(err) + return err + } + + v.SupportSet.Prepare() + v.SupportSet.Setup(v.status.GetVPNSetupArg(v.EnableLocalDNS, v.ForwardIpv6)) + v.SupportSet.OnEmitStatus(0, "Running") + return nil +} + +func initV2Env() { + if os.Getenv(v2Assert) != "" { + return + } + //Initialize asset API, Since Raymond Will not let notify the asset location inside Process, + //We need to set location outside V2Ray + os.Setenv(v2Assert, assetperfix) + //Now we handle read + v2filesystem.NewFileReader = func(path string) (io.ReadCloser, error) { + if strings.HasPrefix(path, assetperfix) { + p := path[len(assetperfix)+1:] + //is it overridden? + //by, ok := overridedAssets[p] + //if ok { + // return os.Open(by) + //} + return mobasset.Open(p) + } + return os.Open(path) + } +} + +//Delegate Funcation +func TestConfig(ConfigureFileContent string) error { + initV2Env() + _, err := v2serial.LoadJSONConfig(strings.NewReader(ConfigureFileContent)) + return err +} + +/*NewV2RayPoint new V2RayPoint*/ +func NewV2RayPoint(s V2RayVPNServiceSupportsSet) *V2RayPoint { + initV2Env() + + // inject our own log writer + v2applog.RegisterHandlerCreator(v2applog.LogType_Console, + func(lt v2applog.LogType, + options v2applog.HandlerCreatorOptions) (v2commlog.Handler, error) { + return v2commlog.NewLogger(createStdoutLogWriter()), nil + }) + + dialer := VPN.NewPreotectedDialer(s) + v2internet.UseAlternativeSystemDialer(dialer) + status := &CoreI.Status{} + return &V2RayPoint{ + SupportSet: s, + v2rayOP: new(sync.Mutex), + status: status, + dialer: dialer, + escorter: &Escort.Escorting{Status: status}, + } +} + +func (v V2RayPoint) runTun2socks() error { + shipb := shippedBinarys.FirstRun{Status: v.status} + if err := shipb.CheckAndExport(); err != nil { + log.Println(err) + return err + } + + v.escorter.EscortingUp() + go v.escorter.EscortRun( + v.status.GetApp("tun2socks"), + v.status.GetTun2socksArgs(v.EnableLocalDNS, v.ForwardIpv6), "", + v.SupportSet.SendFd) + + return nil +} + +/*CheckVersion int +This func will return libv2ray binding version. +*/ +func CheckVersion() int { + return CoreI.CheckVersion() +} + +/*CheckVersionX string +This func will return libv2ray binding version and V2Ray version used. +*/ +func CheckVersionX() string { + return fmt.Sprintf("Libv2rayLite V%d, Core V%s", CheckVersion(), v2core.Version()) +} diff --git a/AndroidLibV2rayLite/libv2ray.go b/AndroidLibV2rayLite/libv2ray.go new file mode 100644 index 00000000..8692373d --- /dev/null +++ b/AndroidLibV2rayLite/libv2ray.go @@ -0,0 +1,3 @@ +package libv2ray + +//go:generate make all diff --git a/AndroidLibV2rayLite/shippedBinarys/ArchDep/386/tun2socks b/AndroidLibV2rayLite/shippedBinarys/ArchDep/386/tun2socks new file mode 100644 index 00000000..f5c05b58 Binary files /dev/null and b/AndroidLibV2rayLite/shippedBinarys/ArchDep/386/tun2socks differ diff --git a/AndroidLibV2rayLite/shippedBinarys/ArchDep/amd64/tun2socks b/AndroidLibV2rayLite/shippedBinarys/ArchDep/amd64/tun2socks new file mode 100644 index 00000000..8f426499 Binary files /dev/null and b/AndroidLibV2rayLite/shippedBinarys/ArchDep/amd64/tun2socks differ diff --git a/AndroidLibV2rayLite/shippedBinarys/ArchDep/arm/tun2socks b/AndroidLibV2rayLite/shippedBinarys/ArchDep/arm/tun2socks new file mode 100644 index 00000000..b1aa74e3 Binary files /dev/null and b/AndroidLibV2rayLite/shippedBinarys/ArchDep/arm/tun2socks differ diff --git a/AndroidLibV2rayLite/shippedBinarys/ArchDep/arm64/tun2socks b/AndroidLibV2rayLite/shippedBinarys/ArchDep/arm64/tun2socks new file mode 100644 index 00000000..b46649ef Binary files /dev/null and b/AndroidLibV2rayLite/shippedBinarys/ArchDep/arm64/tun2socks differ diff --git a/AndroidLibV2rayLite/shippedBinarys/ArchIndep/holder b/AndroidLibV2rayLite/shippedBinarys/ArchIndep/holder new file mode 100644 index 00000000..e69de29b diff --git a/AndroidLibV2rayLite/shippedBinarys/Makefile b/AndroidLibV2rayLite/shippedBinarys/Makefile new file mode 100644 index 00000000..f9c450e0 --- /dev/null +++ b/AndroidLibV2rayLite/shippedBinarys/Makefile @@ -0,0 +1,13 @@ +Platdep=shippedBinary.386 shippedBinary.amd64 shippedBinary.arm64 shippedBinary.arm + +shippedBinaryDep: + go get -u github.com/jteeuwen/go-bindata/... + +shippedBinary.%: + go-bindata -nometadata -nomemcopy -pkg shippedBinarys -o ./binary_$*.go -tags $* ArchIndep/ ArchDep/$*/ + +shippedBinary:shippedBinaryDep $(Platdep) + @echo "Done" + +clean: + -rm binary* diff --git a/AndroidLibV2rayLite/shippedBinarys/firstrun.go b/AndroidLibV2rayLite/shippedBinarys/firstrun.go new file mode 100644 index 00000000..fcbd8c7c --- /dev/null +++ b/AndroidLibV2rayLite/shippedBinarys/firstrun.go @@ -0,0 +1,69 @@ +package shippedBinarys + +import ( + "log" + "os" + "strconv" + + "github.com/2dust/AndroidLibV2rayLite/CoreI" +) + +type FirstRun struct { + Status *CoreI.Status +} + +func (v *FirstRun) checkIfRcExist() error { + datadir := v.Status.GetDataDir() + if _, err := os.Stat(datadir + strconv.Itoa(CoreI.CheckVersion())); !os.IsNotExist(err) { + log.Println("file exists") + return nil + } + + + IndepDir, err := AssetDir("ArchIndep") + log.Println(IndepDir) + if err != nil { + return err + } + for _, fn := range IndepDir { + log.Println(datadir+"ArchIndep/"+fn) + + err := RestoreAsset(datadir, "ArchIndep/"+fn) + log.Println(err) + + //GrantPremission + os.Chmod(datadir+"ArchIndep/"+fn, 0700) + log.Println(os.Remove(datadir + fn)) + log.Println(os.Symlink(datadir+"ArchIndep/"+fn, datadir + fn)) + } + + + DepDir, err := AssetDir("ArchDep") + log.Println(DepDir) + if err != nil { + return err + } + for _, fn := range DepDir { + DepDir2, err := AssetDir("ArchDep/" + fn) + log.Println("ArchDep/" + fn) + if err != nil { + return err + } + for _, FND := range DepDir2 { + log.Println(datadir+"ArchDep/"+fn+"/"+FND) + + RestoreAsset(datadir, "ArchDep/"+fn+"/"+FND) + os.Chmod(datadir+"ArchDep/"+fn+"/"+FND, 0700) + log.Println(os.Remove(datadir + FND)) + log.Println(os.Symlink(datadir+"ArchDep/"+fn+"/"+FND, datadir+FND)) + } + } + s, _ := os.Create(datadir + strconv.Itoa(CoreI.CheckVersion())) + s.Close() + + return nil +} + +func (v *FirstRun) CheckAndExport() error { + return v.checkIfRcExist() +} diff --git a/AndroidLibV2rayLite/tun2socks.mk b/AndroidLibV2rayLite/tun2socks.mk new file mode 100644 index 00000000..99d84cb3 --- /dev/null +++ b/AndroidLibV2rayLite/tun2socks.mk @@ -0,0 +1,128 @@ +# Copyright (C) 2009 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# +LOCAL_PATH := $(call my-dir) +ROOT_PATH := $(LOCAL_PATH) + +######################################################## +## libancillary +######################################################## + +include $(CLEAR_VARS) + +ANCILLARY_SOURCE := fd_recv.c fd_send.c + +LOCAL_MODULE := libancillary +#LOCAL_CFLAGS += -I$(LOCAL_PATH)/libancillary +LOCAL_C_INCLUDES := $(LOCAL_PATH)/libancillary +LOCAL_SRC_FILES := $(addprefix libancillary/, $(ANCILLARY_SOURCE)) + +include $(BUILD_STATIC_LIBRARY) + +######################################################## +## tun2socks +######################################################## + +include $(CLEAR_VARS) + +LOCAL_CFLAGS := -std=gnu99 +LOCAL_CFLAGS += -DBADVPN_THREADWORK_USE_PTHREAD -DBADVPN_LINUX -DBADVPN_BREACTOR_BADVPN -D_GNU_SOURCE +LOCAL_CFLAGS += -DBADVPN_USE_SIGNALFD -DBADVPN_USE_EPOLL +LOCAL_CFLAGS += -DBADVPN_LITTLE_ENDIAN -DBADVPN_THREAD_SAFE +LOCAL_CFLAGS += -DNDEBUG -DANDROID +LOCAL_CFLAGS += -I + +LOCAL_STATIC_LIBRARIES := libancillary + +LOCAL_C_INCLUDES := \ + $(LOCAL_PATH)/badvpn/libancillary \ + $(LOCAL_PATH)/badvpn/lwip/src/include/ipv4 \ + $(LOCAL_PATH)/badvpn/lwip/src/include/ipv6 \ + $(LOCAL_PATH)/badvpn/lwip/src/include \ + $(LOCAL_PATH)/badvpn/lwip/custom \ + $(LOCAL_PATH)/badvpn \ + $(LOCAL_PATH)/libancillary + +TUN2SOCKS_SOURCES := \ + base/BLog_syslog.c \ + system/BReactor_badvpn.c \ + system/BSignal.c \ + system/BConnection_common.c \ + system/BConnection_unix.c \ + system/BTime.c \ + system/BUnixSignal.c \ + system/BNetwork.c \ + flow/StreamRecvInterface.c \ + flow/PacketRecvInterface.c \ + flow/PacketPassInterface.c \ + flow/StreamPassInterface.c \ + flow/SinglePacketBuffer.c \ + flow/BufferWriter.c \ + flow/PacketBuffer.c \ + flow/PacketStreamSender.c \ + flow/PacketPassConnector.c \ + flow/PacketProtoFlow.c \ + flow/PacketPassFairQueue.c \ + flow/PacketProtoEncoder.c \ + flow/PacketProtoDecoder.c \ + socksclient/BSocksClient.c \ + tuntap/BTap.c \ + lwip/src/core/udp.c \ + lwip/src/core/memp.c \ + lwip/src/core/init.c \ + lwip/src/core/pbuf.c \ + lwip/src/core/tcp.c \ + lwip/src/core/tcp_out.c \ + lwip/src/core/netif.c \ + lwip/src/core/def.c \ + lwip/src/core/ip.c \ + lwip/src/core/mem.c \ + lwip/src/core/tcp_in.c \ + lwip/src/core/stats.c \ + lwip/src/core/inet_chksum.c \ + lwip/src/core/timeouts.c \ + lwip/src/core/ipv4/icmp.c \ + lwip/src/core/ipv4/igmp.c \ + lwip/src/core/ipv4/ip4_addr.c \ + lwip/src/core/ipv4/ip4_frag.c \ + lwip/src/core/ipv4/ip4.c \ + lwip/src/core/ipv4/autoip.c \ + lwip/src/core/ipv6/ethip6.c \ + lwip/src/core/ipv6/inet6.c \ + lwip/src/core/ipv6/ip6_addr.c \ + lwip/src/core/ipv6/mld6.c \ + lwip/src/core/ipv6/dhcp6.c \ + lwip/src/core/ipv6/icmp6.c \ + lwip/src/core/ipv6/ip6.c \ + lwip/src/core/ipv6/ip6_frag.c \ + lwip/src/core/ipv6/nd6.c \ + lwip/custom/sys.c \ + tun2socks/tun2socks.c \ + base/DebugObject.c \ + base/BLog.c \ + base/BPending.c \ + system/BDatagram_unix.c \ + flowextra/PacketPassInactivityMonitor.c \ + tun2socks/SocksUdpGwClient.c \ + udpgw_client/UdpGwClient.c + +LOCAL_MODULE := tun2socks + +LOCAL_LDLIBS := -ldl -llog + +LOCAL_SRC_FILES := $(addprefix badvpn/, $(TUN2SOCKS_SOURCES)) + +include $(BUILD_SYSTEM)/build-executable.mk + diff --git a/AndroidLibV2rayLite/ubuntu-cli-install-android-sdk.sh b/AndroidLibV2rayLite/ubuntu-cli-install-android-sdk.sh new file mode 100644 index 00000000..126d74ba --- /dev/null +++ b/AndroidLibV2rayLite/ubuntu-cli-install-android-sdk.sh @@ -0,0 +1,79 @@ +#!/bin/bash + +# Thanks to https://gist.github.com/wenzhixin/43cf3ce909c24948c6e7 +# Execute this script in your home directory. Lines 17 and 21 will prompt you for a y/n + +# Install Oracle JDK 8 +apt-get update +apt-get install -y openjdk-8-jdk +apt-get install -y unzip make expect # NDK stuff + +# Get SDK tools (link from https://developer.android.com/studio/index.html#downloads) +wget -q https://dl.google.com/android/repository/sdk-tools-linux-3859397.zip +mkdir android-sdk-linux +unzip sdk*.zip -d android-sdk-linux + +# Get NDK (https://developer.android.com/ndk/downloads/index.html) +# wget -q https://dl.google.com/android/repository/android-ndk-r15c-linux-x86_64.zip +# unzip android-ndk*.zip >> /dev/null + +ACCEPT_LICENSES_URL=https://gist.githubusercontent.com/xiaokangwang/1489fd223d26581bfec92adb3cb0088e/raw/328eb6925099df5aae3e76790f8232f0fc378f8b/accept-licenses + +ACCEPT_LICENSES_ITEM="android-sdk-license-bcbbd656|intel-android-sysimage-license-1ea702d1|android-sdk-license-2742d1c5" + +# Let it update itself and install some stuff +cd android-sdk-linux/tools + +curl -L -o accept-licenses $ACCEPT_LICENSES_URL + +chmod +x accept-licenses + +./accept-licenses "./android update sdk --use-sdk-wrapper --all --no-ui" $ACCEPT_LICENSES_ITEM >/dev/null + +# Download every build-tools version that has ever existed +# This will save you time! Thank me later for this + +#./accept-licenses "./android update sdk --use-sdk-wrapper --all --no-ui --filter 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27" $ACCEPT_LICENSES_ITEM + +PACKAGE_PARSE_URL=https://gist.githubusercontent.com/xiaokangwang/06268fb23034ed94bc301880e862da09/raw/afd95cbbe2f8c1d9e7b0277b7c5ef39af756a6ee/parse.awk + +reduceout=https://gist.githubusercontent.com/xiaokangwang/4684bdb5c3415b943f52aa4803386480/raw/b46dab1cc60f02c0d87f88f01e27157034218faa/out.awk + +cd bin + +curl -L -o parse.awk $PACKAGE_PARSE_URL + +curl -L -o reduce.awk $reduceout + +sudo apt-get install gawk + +./sdkmanager --verbose --list |awk -f parse.awk > ~/package_to_install + +readarray -t filenames < $HOME/package_to_install + +cat $HOME/package_to_install + +yes|./sdkmanager --verbose "${filenames[@]}" |awk -f reduce.awk + +# If you need additional packages for your app, check available packages with: +# ./android list sdk --all + +# install certain packages with: +# ./android update sdk --no-ui --all --filter 1,2,3,<...>,N +# where N is the number of the package in the list (see previous command) + +./sdkmanager "ndk-bundle" + +# Add the directory containing executables in PATH so that they can be found +echo 'export ANDROID_HOME=$HOME/android-sdk-linux' >> ~/.bashrc +echo 'export PATH=$PATH:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools' >> ~/.bashrc +# echo 'export NDK_HOME=$HOME/android-ndk-r15c' >> ~/.bashrc +# echo 'export ANDROID_NDK_HOME=$NDK_HOME' >> ~/.bashrc + + +source ~/.bashrc + +# Make sure you can execute 32 bit executables if this is 64 bit machine, otherwise skip this +dpkg --add-architecture i386 +apt-get update +apt-get install -y libc6:i386 libstdc++6:i386 zlib1g:i386 diff --git a/AndroidLibV2rayLite/v2logger.go b/AndroidLibV2rayLite/v2logger.go new file mode 100644 index 00000000..e78a5abd --- /dev/null +++ b/AndroidLibV2rayLite/v2logger.go @@ -0,0 +1,32 @@ +package libv2ray + +// This struct creates our own log writer without datatime stamp +// As Android adds time stamps on each line + +import ( + "log" + "os" + + v2commlog "v2ray.com/core/common/log" +) + +type consoleLogWriter struct { + logger *log.Logger +} + +func (w *consoleLogWriter) Write(s string) error { + w.logger.Print(s) + return nil +} + +func (w *consoleLogWriter) Close() error { + return nil +} + +// This logger won't print data/time stamps +func createStdoutLogWriter() v2commlog.WriterCreator { + return func() v2commlog.Writer { + return &consoleLogWriter{ + logger: log.New(os.Stdout, "", 0)} + } +}