vikarti.anatra/safing-portmaster
1
0
Fork 0
mirror of https://github.com/safing/portmaster synced 2025-09-02 02:29:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Remove tunnel integration for now

Browse source
This commit is contained in:
Daniel 2019-02-12 16:35:23 +01:00
parent ca508fd20f
commit 8d38d27e7c
1 changed files with 109 additions and 121 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

230
firewall/tunnel.go
View file

@ -1,123 +1,111 @@
package firewall package firewall
import ( // var (
"errors" // TunnelNet4 *net.IPNet
"log" // TunnelNet6 *net.IPNet
"net" // TunnelEntry4 = net.IPv4(127, 0, 0, 17)
"sync" // TunnelEntry6 = net.ParseIP("fd17::17")
"time" //
// ipToDomainMap = make(map[string]*TunnelInfo)
"github.com/Safing/portbase/crypto/random" // ipToDomainMapLock sync.RWMutex
"github.com/Safing/portmaster/intel" // )
"github.com/miekg/dns" //
) // func init() {
// var err error
var ( // _, TunnelNet4, err = net.ParseCIDR("127.17.0.0/16")
TunnelNet4 *net.IPNet // if err != nil {
TunnelNet6 *net.IPNet // log.Fatalf("portmaster: could not parse 127.17.0.0/16: %s", err)
TunnelEntry4 = net.IPv4(127, 0, 0, 17) // }
TunnelEntry6 = net.ParseIP("fd17::17") // _, TunnelNet6, err = net.ParseCIDR("fd17::/64")
// if err != nil {
ipToDomainMap = make(map[string]*TunnelInfo) // log.Fatalf("portmaster: could not parse fd17::/64: %s", err)
ipToDomainMapLock sync.RWMutex // }
) //
// go tunnelInfoCleaner()
func init() { // }
var err error //
_, TunnelNet4, err = net.ParseCIDR("127.17.0.0/16") // type TunnelInfo struct {
if err != nil { // IP net.IP
log.Fatalf("portmaster: could not parse 127.17.0.0/16: %s", err) // Domain string
} // RRCache *intel.RRCache
_, TunnelNet6, err = net.ParseCIDR("fd17::/64") // Expires int64
if err != nil { // }
log.Fatalf("portmaster: could not parse fd17::/64: %s", err) //
} // func (ti *TunnelInfo) ExportTunnelIP() *intel.RRCache {
// return &intel.RRCache{
go tunnelInfoCleaner() // Answer: []dns.RR{
} // &dns.A{
// Hdr: dns.RR_Header{
type TunnelInfo struct { // Name: ti.Domain,
IP net.IP // Rrtype: 1,
Domain string // Class: 1,
RRCache *intel.RRCache // Ttl: 17,
Expires int64 // Rdlength: 8,
} // },
// A: ti.IP,
func (ti *TunnelInfo) ExportTunnelIP() *intel.RRCache { // },
return &intel.RRCache{ // },
Answer: []dns.RR{ // }
&dns.A{ // }
Hdr: dns.RR_Header{ //
Name: ti.Domain, // func AssignTunnelIP(domain string) (*TunnelInfo, error) {
Rrtype: 1, // ipToDomainMapLock.Lock()
Class: 1, // defer ipToDomainMapLock.Unlock()
Ttl: 17, //
Rdlength: 8, // for i := 0; i < 100; i++ {
}, // // get random IP
A: ti.IP, // r, err := random.Bytes(2)
}, // if err != nil {
}, // return nil, err
} // }
} // randomIP := net.IPv4(127, 17, r[0], r[1])
//
func AssignTunnelIP(domain string) (*TunnelInfo, error) { // // clean after every 20 tries
ipToDomainMapLock.Lock() // if i > 0 && i%20 == 0 {
defer ipToDomainMapLock.Unlock() // cleanExpiredTunnelInfos()
// }
for i := 0; i < 100; i++ { //
// get random IP // // if it does not exist yet, set and return
r, err := random.Bytes(2) // _, ok := ipToDomainMap[randomIP.String()]
if err != nil { // if !ok {
return nil, err // tunnelInfo := &TunnelInfo{
} // IP: randomIP,
randomIP := net.IPv4(127, 17, r[0], r[1]) // Domain: domain,
// Expires: time.Now().Add(5 * time.Minute).Unix(),
// clean after every 20 tries // }
if i > 0 && i%20 == 0 { // ipToDomainMap[randomIP.String()] = tunnelInfo
cleanExpiredTunnelInfos() // return tunnelInfo, nil
} // }
// }
// if it does not exist yet, set and return //
_, ok := ipToDomainMap[randomIP.String()] // return nil, errors.New("could not find available tunnel IP, please retry later")
if !ok { // }
tunnelInfo := &TunnelInfo{ //
IP: randomIP, // func GetTunnelInfo(tunnelIP net.IP) (tunnelInfo *TunnelInfo) {
Domain: domain, // ipToDomainMapLock.RLock()
Expires: time.Now().Add(5 * time.Minute).Unix(), // defer ipToDomainMapLock.RUnlock()
} // var ok bool
ipToDomainMap[randomIP.String()] = tunnelInfo // tunnelInfo, ok = ipToDomainMap[tunnelIP.String()]
return tunnelInfo, nil // if ok && tunnelInfo.Expires >= time.Now().Unix() {
} // return tunnelInfo
} // }
// return nil
return nil, errors.New("could not find available tunnel IP, please retry later") // }
} //
// func tunnelInfoCleaner() {
func GetTunnelInfo(tunnelIP net.IP) (tunnelInfo *TunnelInfo) { // for {
ipToDomainMapLock.RLock() // time.Sleep(5 * time.Minute)
defer ipToDomainMapLock.RUnlock() // ipToDomainMapLock.Lock()
var ok bool // cleanExpiredTunnelInfos()
tunnelInfo, ok = ipToDomainMap[tunnelIP.String()] // ipToDomainMapLock.Unlock()
if ok && tunnelInfo.Expires >= time.Now().Unix() { // }
return tunnelInfo // }
} //
return nil // func cleanExpiredTunnelInfos() {
} // now := time.Now().Unix()
// for domain, tunnelInfo := range ipToDomainMap {
func tunnelInfoCleaner() { // if tunnelInfo.Expires < now {
for { // delete(ipToDomainMap, domain)
time.Sleep(5 * time.Minute) // }
ipToDomainMapLock.Lock() // }
cleanExpiredTunnelInfos() // }
ipToDomainMapLock.Unlock()
}
}
func cleanExpiredTunnelInfos() {
now := time.Now().Unix()
for domain, tunnelInfo := range ipToDomainMap {
if tunnelInfo.Expires < now {
delete(ipToDomainMap, domain)
}
}
}