docstring_tokens stringlengths 0 76.5k | code_tokens stringlengths 75 1.81M | label_window listlengths 4 2.12k | html_url stringlengths 74 116 | file_name stringlengths 3 311 |
|---|---|---|---|---|
// Register an HTTP handler
HTTPRegister func(string, string, func(http.ResponseWriter, *http.Request)) `yaml:"-"` | <mask> // Filtering callback function
<mask> FilterHandler func(clientAddr string, settings *RequestFilteringSettings) `yaml:"-"`
<mask> }
<mask>
<mask> type privateConfig struct {
<mask> parentalServer string // access via methods
<mask> safeBrowsingServer string // access via methods
<mask> }
<mask>
<mask> // LookupStats store stats collected during safebrowsing or parental checks
<mask> type LookupStats struct {
<mask> Requests uint64 // number of HTTP requests that were sent
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Filtering callback function
FilterHandler func(clientAddr string, settings *RequestFilteringSettings) `yaml:"-"`
}
</s> add // Called when the configuration is changed by HTTP request
ConfigModified func() `yaml:"-"` </s> remove Config // for direct access by library users, even a = assignment
privateConfig
</s> add parentalServer string // access via methods
safeBrowsingServer string // access via methods
Config // for direct access by library users, even a = assignment
confLock sync.RWMutex
// Channel for passing data to filters-initializer goroutine
filtersInitializerChan chan filtersInitializerParams
filtersInitializerLock sync.Mutex </s> remove // Create dnsfilter asynchronously.
// Requests won't be filtered until dnsfilter is created.
// If "restart" command is received while we're creating an old dnsfilter object,
// we delay creation of the new object until the old one is created.
AsyncStartup bool `yaml:"-"`
</s> add // Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` </s> remove return names[r]
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
// Parameters to pass to filters-initializer goroutine
type filtersInitializerParams struct {
filters map[int]string
}
| <mask> }
<mask>
<mask> // Dnsfilter holds added rules and performs hostname matches against the rules
<mask> type Dnsfilter struct {
<mask> rulesStorage *urlfilter.RuleStorage
<mask> filteringEngine *urlfilter.DNSEngine
<mask> engineLock sync.RWMutex
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove //go:generate stringer -type=Reason
</s> add </s> remove d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
</s> add filteringEngine := urlfilter.NewDNSEngine(rulesStorage)
d.engineLock.Lock()
if d.rulesStorage != nil {
d.rulesStorage.Close()
}
d.rulesStorage = rulesStorage
d.filteringEngine = filteringEngine
d.engineLock.Unlock()
log.Debug("initialized filtering engine")
</s> remove type dnsfilterCreatorParams struct {
conf dnsfilter.Config
filters map[int]string
}
</s> add </s> remove return names[r]
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
engineLock sync.RWMutex | <mask> rulesStorage *urlfilter.RuleStorage
<mask> filteringEngine *urlfilter.DNSEngine
<mask>
<mask> // HTTP lookups for safebrowsing and parental
<mask> client http.Client // handle for http client -- single instance as recommended by docs
<mask> transport *http.Transport // handle for http transport used by http client
<mask>
<mask> parentalServer string // access via methods
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove Config // for direct access by library users, even a = assignment
privateConfig
</s> add parentalServer string // access via methods
safeBrowsingServer string // access via methods
Config // for direct access by library users, even a = assignment
confLock sync.RWMutex
// Channel for passing data to filters-initializer goroutine
filtersInitializerChan chan filtersInitializerParams
filtersInitializerLock sync.Mutex </s> remove // Filtering callback function
FilterHandler func(clientAddr string, settings *RequestFilteringSettings) `yaml:"-"`
}
</s> add // Called when the configuration is changed by HTTP request
ConfigModified func() `yaml:"-"` </s> remove type privateConfig struct {
parentalServer string // access via methods
safeBrowsingServer string // access via methods
</s> add // Register an HTTP handler
HTTPRegister func(string, string, func(http.ResponseWriter, *http.Request)) `yaml:"-"` </s> remove filteringStarted bool // TRUE if filtering module is started
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
parentalServer string // access via methods
safeBrowsingServer string // access via methods
Config // for direct access by library users, even a = assignment
confLock sync.RWMutex
// Channel for passing data to filters-initializer goroutine
filtersInitializerChan chan filtersInitializerParams
filtersInitializerLock sync.Mutex | <mask> // HTTP lookups for safebrowsing and parental
<mask> client http.Client // handle for http client -- single instance as recommended by docs
<mask> transport *http.Transport // handle for http transport used by http client
<mask>
<mask> Config // for direct access by library users, even a = assignment
<mask> privateConfig
<mask> }
<mask>
<mask> // Filter represents a filter list
<mask> type Filter struct {
<mask> ID int64 // auto-assigned when filter is added (see nextFilterID)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Filtering callback function
FilterHandler func(clientAddr string, settings *RequestFilteringSettings) `yaml:"-"`
}
</s> add // Called when the configuration is changed by HTTP request
ConfigModified func() `yaml:"-"` </s> remove filteringStarted bool // TRUE if filtering module is started
</s> add </s> remove type privateConfig struct {
parentalServer string // access via methods
safeBrowsingServer string // access via methods
</s> add // Register an HTTP handler
HTTPRegister func(string, string, func(http.ResponseWriter, *http.Request)) `yaml:"-"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
<mask> Data []byte `yaml:"-"` // List of rules divided by '\n'
<mask> FilePath string `yaml:"-"` // Path to a filtering rules file
<mask> }
<mask>
<mask> //go:generate stringer -type=Reason
<mask>
<mask> // Reason holds an enum detailing why it was filtered or not filtered
<mask> type Reason int
<mask>
<mask> const (
<mask> // reasons for not filtering
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Create dnsfilter asynchronously.
// Requests won't be filtered until dnsfilter is created.
// If "restart" command is received while we're creating an old dnsfilter object,
// we delay creation of the new object until the old one is created.
AsyncStartup bool `yaml:"-"`
</s> add // Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` </s> remove type privateConfig struct {
parentalServer string // access via methods
safeBrowsingServer string // access via methods
</s> add // Register an HTTP handler
HTTPRegister func(string, string, func(http.ResponseWriter, *http.Request)) `yaml:"-"` </s> remove // Filtering callback function
FilterHandler func(clientAddr string, settings *RequestFilteringSettings) `yaml:"-"`
}
</s> add // Called when the configuration is changed by HTTP request
ConfigModified func() `yaml:"-"` </s> remove Config // for direct access by library users, even a = assignment
privateConfig
</s> add parentalServer string // access via methods
safeBrowsingServer string // access via methods
Config // for direct access by library users, even a = assignment
confLock sync.RWMutex
// Channel for passing data to filters-initializer goroutine
filtersInitializerChan chan filtersInitializerParams
filtersInitializerLock sync.Mutex | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go | |
var reasonNames = []string{
"NotFilteredNotFound",
"NotFilteredWhiteList",
"NotFilteredError",
"FilteredBlackList",
"FilteredSafeBrowsing",
"FilteredParental",
"FilteredInvalid",
"FilteredSafeSearch",
"FilteredBlockedService",
"Rewrite",
}
| <mask> )
<mask>
<mask> func (r Reason) String() string {
<mask> if uint(r) >= uint(len(reasonNames)) {
<mask> return ""
<mask> }
<mask> return reasonNames[r]
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove names := []string{
"NotFilteredNotFound",
"NotFilteredWhiteList",
"NotFilteredError",
</s> add if uint(r) >= uint(len(reasonNames)) {
return ""
}
return reasonNames[r]
}
// GetConfig - get configuration
func (d *Dnsfilter) GetConfig() RequestFilteringSettings {
c := RequestFilteringSettings{}
// d.confLock.RLock()
c.SafeSearchEnabled = d.Config.SafeSearchEnabled
c.SafeBrowsingEnabled = d.Config.SafeBrowsingEnabled
c.ParentalEnabled = d.Config.ParentalEnabled
// d.confLock.RUnlock()
return c
}
// WriteDiskConfig - write configuration
func (d *Dnsfilter) WriteDiskConfig(c *Config) {
*c = d.Config
} </s> remove return names[r]
</s> add </s> remove "Rewrite",
</s> add d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove "FilteredBlackList",
"FilteredSafeBrowsing",
"FilteredParental",
"FilteredInvalid",
"FilteredSafeSearch",
"FilteredBlockedService",
</s> add // SetFilters - set new filters (synchronously or asynchronously)
// When filters are set asynchronously, the old filters continue working until the new filters are ready.
// In this case the caller must ensure that the old filter files are intact.
func (d *Dnsfilter) SetFilters(filters map[int]string, async bool) error {
if async {
params := filtersInitializerParams{
filters: filters,
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
if uint(r) >= uint(len(reasonNames)) {
return ""
}
return reasonNames[r]
}
// GetConfig - get configuration
func (d *Dnsfilter) GetConfig() RequestFilteringSettings {
c := RequestFilteringSettings{}
// d.confLock.RLock()
c.SafeSearchEnabled = d.Config.SafeSearchEnabled
c.SafeBrowsingEnabled = d.Config.SafeBrowsingEnabled
c.ParentalEnabled = d.Config.ParentalEnabled
// d.confLock.RUnlock()
return c
}
// WriteDiskConfig - write configuration
func (d *Dnsfilter) WriteDiskConfig(c *Config) {
*c = d.Config
} | <mask> ReasonRewrite
<mask> )
<mask>
<mask> func (r Reason) String() string {
<mask> names := []string{
<mask> "NotFilteredNotFound",
<mask> "NotFilteredWhiteList",
<mask> "NotFilteredError",
<mask>
<mask> "FilteredBlackList",
<mask> "FilteredSafeBrowsing",
<mask> "FilteredParental",
<mask> "FilteredInvalid",
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove "FilteredBlackList",
"FilteredSafeBrowsing",
"FilteredParental",
"FilteredInvalid",
"FilteredSafeSearch",
"FilteredBlockedService",
</s> add // SetFilters - set new filters (synchronously or asynchronously)
// When filters are set asynchronously, the old filters continue working until the new filters are ready.
// In this case the caller must ensure that the old filter files are intact.
func (d *Dnsfilter) SetFilters(filters map[int]string, async bool) error {
if async {
params := filtersInitializerParams{
filters: filters,
} </s> remove "Rewrite",
</s> add d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil </s> remove // -------------------------------------------------
// helper functions for parsing parameters from body
// -------------------------------------------------
func parseParametersFromBody(r io.Reader) (map[string]string, error) {
parameters := map[string]string{}
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Text()
if len(line) == 0 {
// skip empty lines
continue
}
parts := strings.SplitN(line, "=", 2)
if len(parts) != 2 {
return parameters, errors.New("Got invalid request body")
}
parameters[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
}
return parameters, nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
// SetFilters - set new filters (synchronously or asynchronously)
// When filters are set asynchronously, the old filters continue working until the new filters are ready.
// In this case the caller must ensure that the old filter files are intact.
func (d *Dnsfilter) SetFilters(filters map[int]string, async bool) error {
if async {
params := filtersInitializerParams{
filters: filters,
} | <mask> "NotFilteredNotFound",
<mask> "NotFilteredWhiteList",
<mask> "NotFilteredError",
<mask>
<mask> "FilteredBlackList",
<mask> "FilteredSafeBrowsing",
<mask> "FilteredParental",
<mask> "FilteredInvalid",
<mask> "FilteredSafeSearch",
<mask> "FilteredBlockedService",
<mask>
<mask> "Rewrite",
<mask> }
<mask> if uint(r) >= uint(len(names)) {
<mask> return ""
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove names := []string{
"NotFilteredNotFound",
"NotFilteredWhiteList",
"NotFilteredError",
</s> add if uint(r) >= uint(len(reasonNames)) {
return ""
}
return reasonNames[r]
}
// GetConfig - get configuration
func (d *Dnsfilter) GetConfig() RequestFilteringSettings {
c := RequestFilteringSettings{}
// d.confLock.RLock()
c.SafeSearchEnabled = d.Config.SafeSearchEnabled
c.SafeBrowsingEnabled = d.Config.SafeBrowsingEnabled
c.ParentalEnabled = d.Config.ParentalEnabled
// d.confLock.RUnlock()
return c
}
// WriteDiskConfig - write configuration
func (d *Dnsfilter) WriteDiskConfig(c *Config) {
*c = d.Config
} </s> remove "Rewrite",
</s> add d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil </s> remove return names[r]
</s> add </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil | <mask> "FilteredInvalid",
<mask> "FilteredSafeSearch",
<mask> "FilteredBlockedService",
<mask>
<mask> "Rewrite",
<mask> }
<mask> if uint(r) >= uint(len(names)) {
<mask> return ""
<mask> }
<mask> return names[r]
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove return names[r]
</s> add </s> remove "FilteredBlackList",
"FilteredSafeBrowsing",
"FilteredParental",
"FilteredInvalid",
"FilteredSafeSearch",
"FilteredBlockedService",
</s> add // SetFilters - set new filters (synchronously or asynchronously)
// When filters are set asynchronously, the old filters continue working until the new filters are ready.
// In this case the caller must ensure that the old filter files are intact.
func (d *Dnsfilter) SetFilters(filters map[int]string, async bool) error {
if async {
params := filtersInitializerParams{
filters: filters,
} </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove names := []string{
"NotFilteredNotFound",
"NotFilteredWhiteList",
"NotFilteredError",
</s> add if uint(r) >= uint(len(reasonNames)) {
return ""
}
return reasonNames[r]
}
// GetConfig - get configuration
func (d *Dnsfilter) GetConfig() RequestFilteringSettings {
c := RequestFilteringSettings{}
// d.confLock.RLock()
c.SafeSearchEnabled = d.Config.SafeSearchEnabled
c.SafeBrowsingEnabled = d.Config.SafeBrowsingEnabled
c.ParentalEnabled = d.Config.ParentalEnabled
// d.confLock.RUnlock()
return c
}
// WriteDiskConfig - write configuration
func (d *Dnsfilter) WriteDiskConfig(c *Config) {
*c = d.Config
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() | <mask> "FilteredBlockedService",
<mask>
<mask> "Rewrite",
<mask> }
<mask> if uint(r) >= uint(len(names)) {
<mask> return ""
<mask> }
<mask> return names[r]
<mask> }
<mask>
<mask> type dnsFilterContext struct {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove return names[r]
</s> add </s> remove "Rewrite",
</s> add d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil </s> remove "FilteredBlackList",
"FilteredSafeBrowsing",
"FilteredParental",
"FilteredInvalid",
"FilteredSafeSearch",
"FilteredBlockedService",
</s> add // SetFilters - set new filters (synchronously or asynchronously)
// When filters are set asynchronously, the old filters continue working until the new filters are ready.
// In this case the caller must ensure that the old filter files are intact.
func (d *Dnsfilter) SetFilters(filters map[int]string, async bool) error {
if async {
params := filtersInitializerParams{
filters: filters,
} </s> remove names := []string{
"NotFilteredNotFound",
"NotFilteredWhiteList",
"NotFilteredError",
</s> add if uint(r) >= uint(len(reasonNames)) {
return ""
}
return reasonNames[r]
}
// GetConfig - get configuration
func (d *Dnsfilter) GetConfig() RequestFilteringSettings {
c := RequestFilteringSettings{}
// d.confLock.RLock()
c.SafeSearchEnabled = d.Config.SafeSearchEnabled
c.SafeBrowsingEnabled = d.Config.SafeBrowsingEnabled
c.ParentalEnabled = d.Config.ParentalEnabled
// d.confLock.RUnlock()
return c
}
// WriteDiskConfig - write configuration
func (d *Dnsfilter) WriteDiskConfig(c *Config) {
*c = d.Config
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
<mask> }
<mask> if uint(r) >= uint(len(names)) {
<mask> return ""
<mask> }
<mask> return names[r]
<mask> }
<mask>
<mask> type dnsFilterContext struct {
<mask> stats Stats
<mask> dialCache gcache.Cache // "host" -> "IP" cache for safebrowsing and parental control servers
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove "Rewrite",
</s> add d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil </s> remove type privateConfig struct {
parentalServer string // access via methods
safeBrowsingServer string // access via methods
</s> add // Register an HTTP handler
HTTPRegister func(string, string, func(http.ResponseWriter, *http.Request)) `yaml:"-"` </s> remove "FilteredBlackList",
"FilteredSafeBrowsing",
"FilteredParental",
"FilteredInvalid",
"FilteredSafeSearch",
"FilteredBlockedService",
</s> add // SetFilters - set new filters (synchronously or asynchronously)
// When filters are set asynchronously, the old filters continue working until the new filters are ready.
// In this case the caller must ensure that the old filter files are intact.
func (d *Dnsfilter) SetFilters(filters map[int]string, async bool) error {
if async {
params := filtersInitializerParams{
filters: filters,
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go | |
d.confLock.RLock()
defer d.confLock.RUnlock()
| <mask> func (d *Dnsfilter) processRewrites(host string, qtype uint16) Result {
<mask> var res Result
<mask>
<mask> for _, r := range d.Rewrites {
<mask> if r.Domain != host {
<mask> continue
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
</s> add filteringEngine := urlfilter.NewDNSEngine(rulesStorage)
d.engineLock.Lock()
if d.rulesStorage != nil {
d.rulesStorage.Close()
}
d.rulesStorage = rulesStorage
d.filteringEngine = filteringEngine
d.engineLock.Unlock()
log.Debug("initialized filtering engine")
</s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove var res dnsfilter.Result
req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
dnsFilter := s.dnsFilter
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
rulesStorage, err := urlfilter.NewRuleStorage(listArray) | <mask> }
<mask> listArray = append(listArray, list)
<mask> }
<mask>
<mask> var err error
<mask> d.rulesStorage, err = urlfilter.NewRuleStorage(listArray)
<mask> if err != nil {
<mask> return fmt.Errorf("urlfilter.NewRuleStorage(): %s", err)
<mask> }
<mask> d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
<mask> return nil
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
</s> add filteringEngine := urlfilter.NewDNSEngine(rulesStorage)
d.engineLock.Lock()
if d.rulesStorage != nil {
d.rulesStorage.Close()
}
d.rulesStorage = rulesStorage
d.filteringEngine = filteringEngine
d.engineLock.Unlock()
log.Debug("initialized filtering engine")
</s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove var err error
</s> add </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add </s> remove if !config.filteringStarted {
config.filteringStarted = true
startRefreshFilters()
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
filteringEngine := urlfilter.NewDNSEngine(rulesStorage)
d.engineLock.Lock()
if d.rulesStorage != nil {
d.rulesStorage.Close()
}
d.rulesStorage = rulesStorage
d.filteringEngine = filteringEngine
d.engineLock.Unlock()
log.Debug("initialized filtering engine")
| <mask> d.rulesStorage, err = urlfilter.NewRuleStorage(listArray)
<mask> if err != nil {
<mask> return fmt.Errorf("urlfilter.NewRuleStorage(): %s", err)
<mask> }
<mask> d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
<mask> return nil
<mask> }
<mask>
<mask> // matchHost is a low-level way to check only if hostname is filtered by rules, skipping expensive safebrowsing and parental lookups
<mask> func (d *Dnsfilter) matchHost(host string, qtype uint16) (Result, error) {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove var err error
d.rulesStorage, err = urlfilter.NewRuleStorage(listArray)
</s> add rulesStorage, err := urlfilter.NewRuleStorage(listArray) </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
d.engineLock.RLock()
defer d.engineLock.RUnlock() | <mask>
<mask> // matchHost is a low-level way to check only if hostname is filtered by rules, skipping expensive safebrowsing and parental lookups
<mask> func (d *Dnsfilter) matchHost(host string, qtype uint16) (Result, error) {
<mask> if d.filteringEngine == nil {
<mask> return Result{}, nil
<mask> }
<mask>
<mask> rules, ok := d.filteringEngine.Match(host)
<mask> if !ok {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
</s> add filteringEngine := urlfilter.NewDNSEngine(rulesStorage)
d.engineLock.Lock()
if d.rulesStorage != nil {
d.rulesStorage.Close()
}
d.rulesStorage = rulesStorage
d.filteringEngine = filteringEngine
d.engineLock.Unlock()
log.Debug("initialized filtering engine")
</s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove var res dnsfilter.Result
req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
dnsFilter := s.dnsFilter
</s> add </s> remove // Destroy is optional if you want to tidy up goroutines without waiting for them to die off
// right now it closes idle HTTP connections if there are any
func (d *Dnsfilter) Destroy() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close()
d.rulesStorage = nil
</s> add if d.Config.HTTPRegister != nil { // for tests
d.registerSecurityHandlers()
d.registerRewritesHandlers() | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
d.Close() | <mask> if filters != nil {
<mask> err := d.initFiltering(filters)
<mask> if err != nil {
<mask> log.Error("Can't initialize filtering subsystem: %s", err)
<mask> d.Destroy()
<mask> return nil
<mask> }
<mask> }
<mask>
<mask> return d
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove var err error
d.rulesStorage, err = urlfilter.NewRuleStorage(listArray)
</s> add rulesStorage, err := urlfilter.NewRuleStorage(listArray) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
d.filtersInitializerChan = make(chan filtersInitializerParams, 1)
go d.filtersInitializer() | <mask> return nil
<mask> }
<mask> }
<mask>
<mask> return d
<mask> }
<mask>
<mask> // Destroy is optional if you want to tidy up goroutines without waiting for them to die off
<mask> // right now it closes idle HTTP connections if there are any
<mask> func (d *Dnsfilter) Destroy() {
<mask> if d != nil && d.transport != nil {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Destroy is optional if you want to tidy up goroutines without waiting for them to die off
// right now it closes idle HTTP connections if there are any
func (d *Dnsfilter) Destroy() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close()
d.rulesStorage = nil
</s> add if d.Config.HTTPRegister != nil { // for tests
d.registerSecurityHandlers()
d.registerRewritesHandlers() </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove if s.dnsFilter != nil || s.dnsProxy != nil {
</s> add if s.dnsProxy != nil { </s> remove d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
</s> add filteringEngine := urlfilter.NewDNSEngine(rulesStorage)
d.engineLock.Lock()
if d.rulesStorage != nil {
d.rulesStorage.Close()
}
d.rulesStorage = rulesStorage
d.filteringEngine = filteringEngine
d.engineLock.Unlock()
log.Debug("initialized filtering engine")
| [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
if d.Config.HTTPRegister != nil { // for tests
d.registerSecurityHandlers()
d.registerRewritesHandlers() | <mask>
<mask> return d
<mask> }
<mask>
<mask> // Destroy is optional if you want to tidy up goroutines without waiting for them to die off
<mask> // right now it closes idle HTTP connections if there are any
<mask> func (d *Dnsfilter) Destroy() {
<mask> if d != nil && d.transport != nil {
<mask> d.transport.CloseIdleConnections()
<mask> }
<mask>
<mask> if d.rulesStorage != nil {
<mask> d.rulesStorage.Close()
<mask> d.rulesStorage = nil
<mask> }
<mask> }
<mask>
<mask> //
<mask> // config manipulation helpers
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove return d
}
</s> add d.filtersInitializerChan = make(chan filtersInitializerParams, 1)
go d.filtersInitializer() </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
</s> add filteringEngine := urlfilter.NewDNSEngine(rulesStorage)
d.engineLock.Lock()
if d.rulesStorage != nil {
d.rulesStorage.Close()
}
d.rulesStorage = rulesStorage
d.filteringEngine = filteringEngine
d.engineLock.Unlock()
log.Debug("initialized filtering engine")
</s> remove if s.dnsFilter != nil || s.dnsProxy != nil {
</s> add if s.dnsProxy != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
return d | <mask> d.registerSecurityHandlers()
<mask> d.registerRewritesHandlers()
<mask> }
<mask> }
<mask>
<mask> //
<mask> // config manipulation helpers
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Destroy is optional if you want to tidy up goroutines without waiting for them to die off
// right now it closes idle HTTP connections if there are any
func (d *Dnsfilter) Destroy() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close()
d.rulesStorage = nil
</s> add if d.Config.HTTPRegister != nil { // for tests
d.registerSecurityHandlers()
d.registerRewritesHandlers() </s> remove // -------------------------------------------------
// helper functions for parsing parameters from body
// -------------------------------------------------
func parseParametersFromBody(r io.Reader) (map[string]string, error) {
parameters := map[string]string{}
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Text()
if len(line) == 0 {
// skip empty lines
continue
}
parts := strings.SplitN(line, "=", 2)
if len(parts) != 2 {
return parameters, errors.New("Got invalid request body")
}
parameters[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
}
return parameters, nil
}
</s> add </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove "Rewrite",
</s> add d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter.go |
defer d.Close() | <mask> addr, addr6)
<mask> filters := make(map[int]string)
<mask> filters[0] = text
<mask> d := NewForTest(nil, filters)
<mask> defer d.Destroy()
<mask>
<mask> d.checkMatchIP(t, "google.com", addr, dns.TypeA)
<mask> d.checkMatchIP(t, "www.google.com", addr, dns.TypeA)
<mask> d.checkMatchEmpty(t, "subdomain.google.com")
<mask> d.checkMatchEmpty(t, "example.org")
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove s := NewServer(nil, nil)
</s> add rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filters := map[int]string{}
filters[0] = rules
c := dnsfilter.Config{}
c.SafeBrowsingEnabled = true
c.SafeBrowsingCacheSize = 1000
c.SafeSearchEnabled = true
c.SafeSearchCacheSize = 1000
c.ParentalCacheSize = 1000
c.CacheTime = 30
f := dnsfilter.New(&c, filters)
s := NewServer(f, nil, nil) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask> for _, tc := range testCases {
<mask> t.Run(fmt.Sprintf("%s in %s", tc, _Func()), func(t *testing.T) {
<mask> d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> gctx.stats.Safebrowsing.Requests = 0
<mask> d.checkMatch(t, "wmconvirus.narod.ru")
<mask> d.checkMatch(t, "wmconvirus.narod.ru")
<mask> if gctx.stats.Safebrowsing.Requests != 1 {
<mask> t.Errorf("Safebrowsing lookup positive cache is not working: %v", gctx.stats.Safebrowsing.Requests)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask>
<mask> func TestParallelSB(t *testing.T) {
<mask> d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> t.Run("group", func(t *testing.T) {
<mask> for i := 0; i < 100; i++ {
<mask> t.Run(fmt.Sprintf("aaa%d", i), func(t *testing.T) {
<mask> t.Parallel()
<mask> d.checkMatch(t, "wmconvirus.narod.ru")
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask>
<mask> // the only way to verify that custom server option is working is to point it at a server that does serve safebrowsing
<mask> func TestSafeBrowsingCustomServerFail(t *testing.T) {
<mask> d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
<mask> // w.Write("Hello, client")
<mask> fmt.Fprintln(w, "Hello, client")
<mask> }))
<mask> defer ts.Close()
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> // SAFE SEARCH
<mask>
<mask> func TestSafeSearch(t *testing.T) {
<mask> d := NewForTest(nil, nil)
<mask> defer d.Destroy()
<mask> _, ok := d.SafeSearchDomain("www.google.com")
<mask> if ok {
<mask> t.Errorf("Expected safesearch to error when disabled")
<mask> }
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> t.Errorf("Expected safesearch to error when disabled")
<mask> }
<mask>
<mask> d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> val, ok := d.SafeSearchDomain("www.google.com")
<mask> if !ok {
<mask> t.Errorf("Expected safesearch to find result for www.google.com")
<mask> }
<mask> if val != "forcesafesearch.google.com" {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask>
<mask> func TestCheckHostSafeSearchYandex(t *testing.T) {
<mask> d := NewForTest(&Config{SafeSearchEnabled: true}, nil)
<mask> defer d.Destroy()
<mask>
<mask> // Slice of yandex domains
<mask> yandex := []string{"yAndeX.ru", "YANdex.COM", "yandex.ua", "yandex.by", "yandex.kz", "www.yandex.com"}
<mask>
<mask> // Check host for each domain
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask>
<mask> func TestCheckHostSafeSearchGoogle(t *testing.T) {
<mask> d := NewForTest(&Config{SafeSearchEnabled: true}, nil)
<mask> defer d.Destroy()
<mask>
<mask> // Slice of google domains
<mask> googleDomains := []string{"www.google.com", "www.google.im", "www.google.co.in", "www.google.iq", "www.google.is", "www.google.it", "www.google.je"}
<mask>
<mask> // Check host for each domain
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask>
<mask> func TestSafeSearchCacheYandex(t *testing.T) {
<mask> d := NewForTest(nil, nil)
<mask> defer d.Destroy()
<mask> domain := "yandex.ru"
<mask>
<mask> var result Result
<mask> var err error
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> t.Fatalf("SafeSearch is not enabled but there is an answer for `%s` !", domain)
<mask> }
<mask>
<mask> d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
<mask> defer d.Destroy()
<mask>
<mask> result, err = d.CheckHost(domain, dns.TypeA, &setts)
<mask> if err != nil {
<mask> t.Fatalf("CheckHost for safesearh domain %s failed cause %s", domain, err)
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask>
<mask> func TestSafeSearchCacheGoogle(t *testing.T) {
<mask> d := NewForTest(nil, nil)
<mask> defer d.Destroy()
<mask> domain := "www.google.ru"
<mask> result, err := d.CheckHost(domain, dns.TypeA, &setts)
<mask> if err != nil {
<mask> t.Fatalf("Cannot check host due to %s", err)
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> t.Fatalf("SafeSearch is not enabled but there is an answer!")
<mask> }
<mask>
<mask> d = NewForTest(&Config{SafeSearchEnabled: true}, nil)
<mask> defer d.Destroy()
<mask>
<mask> // Let's lookup for safesearch domain
<mask> safeDomain, ok := d.SafeSearchDomain(domain)
<mask> if !ok {
<mask> t.Fatalf("Failed to get safesearch domain for %s", domain)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> // PARENTAL
<mask>
<mask> func TestParentalControl(t *testing.T) {
<mask> d := NewForTest(&Config{ParentalEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> d.ParentalSensitivity = 3
<mask> d.checkMatch(t, "pornhub.com")
<mask> d.checkMatch(t, "pornhub.com")
<mask> if gctx.stats.Parental.Requests != 1 {
<mask> t.Errorf("Parental lookup positive cache is not working")
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> t.Run(fmt.Sprintf("%s-%s", test.testname, test.hostname), func(t *testing.T) {
<mask> filters := make(map[int]string)
<mask> filters[0] = test.rules
<mask> d := NewForTest(nil, filters)
<mask> defer d.Destroy()
<mask>
<mask> ret, err := d.CheckHost(test.hostname, dns.TypeA, &setts)
<mask> if err != nil {
<mask> t.Errorf("Error while matching host %s: %s", test.hostname, err)
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> var r Result
<mask> filters := make(map[int]string)
<mask> filters[0] = "||example.org^\n"
<mask> d := NewForTest(&Config{ParentalEnabled: true, SafeBrowsingEnabled: false}, filters)
<mask> defer d.Destroy()
<mask> d.ParentalSensitivity = 3
<mask>
<mask> // no client settings:
<mask>
<mask> // blocked by filters
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove s := NewServer(nil, nil)
</s> add rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filters := map[int]string{}
filters[0] = rules
c := dnsfilter.Config{}
c.SafeBrowsingEnabled = true
c.SafeBrowsingCacheSize = 1000
c.SafeSearchEnabled = true
c.SafeSearchCacheSize = 1000
c.ParentalCacheSize = 1000
c.CacheTime = 30
f := dnsfilter.New(&c, filters)
s := NewServer(f, nil, nil) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> // BENCHMARKS
<mask>
<mask> func BenchmarkSafeBrowsing(b *testing.B) {
<mask> d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> for n := 0; n < b.N; n++ {
<mask> hostname := "wmconvirus.narod.ru"
<mask> ret, err := d.CheckHost(hostname, dns.TypeA, &setts)
<mask> if err != nil {
<mask> b.Errorf("Error while matching host %s: %s", hostname, err)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask>
<mask> func BenchmarkSafeBrowsingParallel(b *testing.B) {
<mask> d := NewForTest(&Config{SafeBrowsingEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> b.RunParallel(func(pb *testing.PB) {
<mask> for pb.Next() {
<mask> hostname := "wmconvirus.narod.ru"
<mask> ret, err := d.CheckHost(hostname, dns.TypeA, &setts)
<mask> if err != nil {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask>
<mask> func BenchmarkSafeSearch(b *testing.B) {
<mask> d := NewForTest(&Config{SafeSearchEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> for n := 0; n < b.N; n++ {
<mask> val, ok := d.SafeSearchDomain("www.google.com")
<mask> if !ok {
<mask> b.Errorf("Expected safesearch to find result for www.google.com")
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
defer d.Close() | <mask> }
<mask>
<mask> func BenchmarkSafeSearchParallel(b *testing.B) {
<mask> d := NewForTest(&Config{SafeSearchEnabled: true}, nil)
<mask> defer d.Destroy()
<mask> b.RunParallel(func(pb *testing.PB) {
<mask> for pb.Next() {
<mask> val, ok := d.SafeSearchDomain("www.google.com")
<mask> if !ok {
<mask> b.Errorf("Expected safesearch to find result for www.google.com")
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsfilter/dnsfilter_test.go |
<mask>
<mask> import (
<mask> "crypto/tls"
<mask> "errors"
<mask> "fmt"
<mask> "net"
<mask> "net/http"
<mask> "strings"
<mask> "sync"
<mask> "time"
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove "bufio"
</s> add </s> remove "io"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
<mask> dnsFilter *dnsfilter.Dnsfilter // DNS filter instance
<mask> queryLog querylog.QueryLog // Query log instance
<mask> stats stats.Stats
<mask>
<mask> // How many times the server was started
<mask> // While creating a dnsfilter object,
<mask> // we use this value to set s.dnsFilter property only with the most recent settings.
<mask> startCounter uint32
<mask> dnsfilterCreatorChan chan dnsfilterCreatorParams
<mask>
<mask> AllowedClients map[string]bool // IP addresses of whitelist clients
<mask> DisallowedClients map[string]bool // IP addresses of clients that should be blocked
<mask> AllowedClientsIPNet []net.IPNet // CIDRs of whitelist clients
<mask> DisallowedClientsIPNet []net.IPNet // CIDRs of clients that should be blocked
<mask> BlockedHosts map[string]bool // hosts that should be blocked
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Create dnsfilter asynchronously.
// Requests won't be filtered until dnsfilter is created.
// If "restart" command is received while we're creating an old dnsfilter object,
// we delay creation of the new object until the old one is created.
AsyncStartup bool `yaml:"-"`
</s> add // Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` </s> remove type dnsfilterCreatorParams struct {
conf dnsfilter.Config
filters map[int]string
}
</s> add </s> remove func NewServer(stats stats.Stats, queryLog querylog.QueryLog) *Server {
</s> add func NewServer(dnsFilter *dnsfilter.Dnsfilter, stats stats.Stats, queryLog querylog.QueryLog) *Server { </s> remove // . Stop server
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
<mask> sync.RWMutex
<mask> conf ServerConfig
<mask> }
<mask>
<mask> type dnsfilterCreatorParams struct {
<mask> conf dnsfilter.Config
<mask> filters map[int]string
<mask> }
<mask>
<mask> // NewServer creates a new instance of the dnsforward.Server
<mask> // Note: this function must be called only once
<mask> func NewServer(stats stats.Stats, queryLog querylog.QueryLog) *Server {
<mask> s := &Server{}
<mask> s.stats = stats
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove func NewServer(stats stats.Stats, queryLog querylog.QueryLog) *Server {
</s> add func NewServer(dnsFilter *dnsfilter.Dnsfilter, stats stats.Stats, queryLog querylog.QueryLog) *Server { </s> remove // How many times the server was started
// While creating a dnsfilter object,
// we use this value to set s.dnsFilter property only with the most recent settings.
startCounter uint32
dnsfilterCreatorChan chan dnsfilterCreatorParams
</s> add </s> remove CacheSize uint `yaml:"cache_size"` // DNS cache size (in bytes)
dnsfilter.Config `yaml:",inline"`
</s> add CacheSize uint `yaml:"cache_size"` // DNS cache size (in bytes)
DnsfilterConf dnsfilter.Config `yaml:",inline"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
func NewServer(dnsFilter *dnsfilter.Dnsfilter, stats stats.Stats, queryLog querylog.QueryLog) *Server { | <mask> }
<mask>
<mask> // NewServer creates a new instance of the dnsforward.Server
<mask> // Note: this function must be called only once
<mask> func NewServer(stats stats.Stats, queryLog querylog.QueryLog) *Server {
<mask> s := &Server{}
<mask> s.stats = stats
<mask> s.queryLog = queryLog
<mask> return s
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove type dnsfilterCreatorParams struct {
conf dnsfilter.Config
filters map[int]string
}
</s> add </s> remove // How many times the server was started
// While creating a dnsfilter object,
// we use this value to set s.dnsFilter property only with the most recent settings.
startCounter uint32
dnsfilterCreatorChan chan dnsfilterCreatorParams
</s> add </s> remove s := NewServer(nil, nil)
</s> add rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filters := map[int]string{}
filters[0] = rules
c := dnsfilter.Config{}
c.SafeBrowsingEnabled = true
c.SafeBrowsingCacheSize = 1000
c.SafeSearchEnabled = true
c.SafeSearchCacheSize = 1000
c.ParentalCacheSize = 1000
c.CacheTime = 30
f := dnsfilter.New(&c, filters)
s := NewServer(f, nil, nil) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
s.dnsFilter = dnsFilter | <mask> // NewServer creates a new instance of the dnsforward.Server
<mask> // Note: this function must be called only once
<mask> func NewServer(dnsFilter *dnsfilter.Dnsfilter, stats stats.Stats, queryLog querylog.QueryLog) *Server {
<mask> s := &Server{}
<mask> s.stats = stats
<mask> s.queryLog = queryLog
<mask> return s
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove func NewServer(stats stats.Stats, queryLog querylog.QueryLog) *Server {
</s> add func NewServer(dnsFilter *dnsfilter.Dnsfilter, stats stats.Stats, queryLog querylog.QueryLog) *Server { </s> remove type dnsfilterCreatorParams struct {
conf dnsfilter.Config
filters map[int]string
}
</s> add </s> remove // How many times the server was started
// While creating a dnsfilter object,
// we use this value to set s.dnsFilter property only with the most recent settings.
startCounter uint32
dnsfilterCreatorChan chan dnsfilterCreatorParams
</s> add </s> remove s := NewServer(nil, nil)
</s> add rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filters := map[int]string{}
filters[0] = rules
c := dnsfilter.Config{}
c.SafeBrowsingEnabled = true
c.SafeBrowsingCacheSize = 1000
c.SafeSearchEnabled = true
c.SafeSearchCacheSize = 1000
c.ParentalCacheSize = 1000
c.CacheTime = 30
f := dnsfilter.New(&c, filters)
s := NewServer(f, nil, nil) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
s.dnsFilter = nil | <mask>
<mask> func (s *Server) Close() {
<mask> s.Lock()
<mask> s.stats = nil
<mask> s.queryLog = nil
<mask> s.Unlock()
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove if s.dnsFilter != nil {
s.dnsFilter.Destroy()
s.dnsFilter = nil
}
</s> add </s> remove func NewServer(stats stats.Stats, queryLog querylog.QueryLog) *Server {
</s> add func NewServer(dnsFilter *dnsfilter.Dnsfilter, stats stats.Stats, queryLog querylog.QueryLog) *Server { </s> remove if s.dnsFilter != nil || s.dnsProxy != nil {
</s> add if s.dnsProxy != nil { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
// Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` | <mask>
<mask> // FilteringConfig represents the DNS filtering configuration of AdGuard Home
<mask> // The zero FilteringConfig is empty and ready for use.
<mask> type FilteringConfig struct {
<mask> // Create dnsfilter asynchronously.
<mask> // Requests won't be filtered until dnsfilter is created.
<mask> // If "restart" command is received while we're creating an old dnsfilter object,
<mask> // we delay creation of the new object until the old one is created.
<mask> AsyncStartup bool `yaml:"-"`
<mask>
<mask> ProtectionEnabled bool `yaml:"protection_enabled"` // whether or not use any of dnsfilter features
<mask> FilteringEnabled bool `yaml:"filtering_enabled"` // whether or not use filter lists
<mask> FiltersUpdateIntervalHours uint32 `yaml:"filters_update_interval"` // time period to update filters (in hours)
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // How many times the server was started
// While creating a dnsfilter object,
// we use this value to set s.dnsFilter property only with the most recent settings.
startCounter uint32
dnsfilterCreatorChan chan dnsfilterCreatorParams
</s> add </s> remove // . If filter data has changed, save it on disk
// . Apply changes to the current configuration
// . Start server
</s> add // . If filter data has changed: rename the old file, store the new data on disk
// . Pass new filters to dnsfilter object </s> remove Filters []dnsfilter.Filter // A list of filters to use
</s> add </s> remove //go:generate stringer -type=Reason
</s> add </s> remove ResolverAddress string // DNS server address
</s> add ResolverAddress string `yaml:"-"` // DNS server address | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
CacheSize uint `yaml:"cache_size"` // DNS cache size (in bytes)
DnsfilterConf dnsfilter.Config `yaml:",inline"` | <mask> // Names of services to block (globally).
<mask> // Per-client settings can override this configuration.
<mask> BlockedServices []string `yaml:"blocked_services"`
<mask>
<mask> CacheSize uint `yaml:"cache_size"` // DNS cache size (in bytes)
<mask> dnsfilter.Config `yaml:",inline"`
<mask> }
<mask>
<mask> // TLSConfig is the TLS configuration for HTTPS, DNS-over-HTTPS, and DNS-over-TLS
<mask> type TLSConfig struct {
<mask> TLSListenAddr *net.TCPAddr `yaml:"-" json:"-"`
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove ResolverAddress string // DNS server address
</s> add ResolverAddress string `yaml:"-"` // DNS server address </s> remove // Filtering callback function
FilterHandler func(clientAddr string, settings *RequestFilteringSettings) `yaml:"-"`
}
</s> add // Called when the configuration is changed by HTTP request
ConfigModified func() `yaml:"-"` </s> remove Filters []dnsfilter.Filter // A list of filters to use
</s> add </s> remove // Create dnsfilter asynchronously.
// Requests won't be filtered until dnsfilter is created.
// If "restart" command is received while we're creating an old dnsfilter object,
// we delay creation of the new object until the old one is created.
AsyncStartup bool `yaml:"-"`
</s> add // Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` </s> remove type dnsfilterCreatorParams struct {
conf dnsfilter.Config
filters map[int]string
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
<mask> UDPListenAddr *net.UDPAddr // UDP listen address
<mask> TCPListenAddr *net.TCPAddr // TCP listen address
<mask> Upstreams []upstream.Upstream // Configured upstreams
<mask> DomainsReservedUpstreams map[string][]upstream.Upstream // Map of domains and lists of configured upstreams
<mask> Filters []dnsfilter.Filter // A list of filters to use
<mask> OnDNSRequest func(d *proxy.DNSContext)
<mask>
<mask> FilteringConfig
<mask> TLSConfig
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Create dnsfilter asynchronously.
// Requests won't be filtered until dnsfilter is created.
// If "restart" command is received while we're creating an old dnsfilter object,
// we delay creation of the new object until the old one is created.
AsyncStartup bool `yaml:"-"`
</s> add // Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` </s> remove CacheSize uint `yaml:"cache_size"` // DNS cache size (in bytes)
dnsfilter.Config `yaml:",inline"`
</s> add CacheSize uint `yaml:"cache_size"` // DNS cache size (in bytes)
DnsfilterConf dnsfilter.Config `yaml:",inline"` </s> remove ResolverAddress string // DNS server address
</s> add ResolverAddress string `yaml:"-"` // DNS server address </s> remove // How many times the server was started
// While creating a dnsfilter object,
// we use this value to set s.dnsFilter property only with the most recent settings.
startCounter uint32
dnsfilterCreatorChan chan dnsfilterCreatorParams
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
if s.dnsProxy != nil { | <mask> }
<mask>
<mask> // startInternal starts without locking
<mask> func (s *Server) startInternal(config *ServerConfig) error {
<mask> if s.dnsFilter != nil || s.dnsProxy != nil {
<mask> return errors.New("DNS server is already started")
<mask> }
<mask>
<mask> err := s.initDNSFilter(config)
<mask> if err != nil {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost </s> remove if s.dnsFilter != nil {
s.dnsFilter.Destroy()
s.dnsFilter = nil
}
</s> add </s> remove var res dnsfilter.Result
req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
dnsFilter := s.dnsFilter
</s> add </s> remove var err error
</s> add </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost | <mask> if s.dnsFilter != nil || s.dnsProxy != nil {
<mask> return errors.New("DNS server is already started")
<mask> }
<mask>
<mask> err := s.initDNSFilter(config)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> proxyConfig := proxy.Config{
<mask> UDPListenAddr: s.conf.UDPListenAddr,
<mask> TCPListenAddr: s.conf.TCPListenAddr,
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove if s.dnsFilter != nil || s.dnsProxy != nil {
</s> add if s.dnsProxy != nil { </s> remove var err error
</s> add </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") </s> remove var res dnsfilter.Result
req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
dnsFilter := s.dnsFilter
</s> add </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
err := processIPCIDRArray(&s.AllowedClients, &s.AllowedClientsIPNet, s.conf.AllowedClients) | <mask> RequestHandler: s.handleDNSRequest,
<mask> AllServers: s.conf.AllServers,
<mask> }
<mask>
<mask> err = processIPCIDRArray(&s.AllowedClients, &s.AllowedClientsIPNet, s.conf.AllowedClients)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> err = processIPCIDRArray(&s.DisallowedClients, &s.DisallowedClientsIPNet, s.conf.DisallowedClients)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove
err = startDNSServer()
if err != nil {
log.Fatal(err)
}
</s> add go func() {
err = startDNSServer()
if err != nil {
log.Fatal(err)
}
}() </s> remove var err error
d.rulesStorage, err = urlfilter.NewRuleStorage(listArray)
</s> add rulesStorage, err := urlfilter.NewRuleStorage(listArray) </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
<mask> s.dnsProxy = &proxy.Proxy{Config: proxyConfig}
<mask> return s.dnsProxy.Start()
<mask> }
<mask>
<mask> // Initializes the DNS filter
<mask> func (s *Server) initDNSFilter(config *ServerConfig) error {
<mask> if config != nil {
<mask> s.conf = *config
<mask> }
<mask>
<mask> var filters map[int]string
<mask> filters = nil
<mask> if s.conf.FilteringEnabled {
<mask> filters = make(map[int]string)
<mask> for _, f := range s.conf.Filters {
<mask> if f.ID == 0 {
<mask> filters[int(f.ID)] = string(f.Data)
<mask> } else {
<mask> filters[int(f.ID)] = f.FilePath
<mask> }
<mask> }
<mask> }
<mask>
<mask> if len(s.conf.ParentalBlockHost) == 0 {
<mask> s.conf.ParentalBlockHost = parentalBlockHost
<mask> }
<mask> if len(s.conf.SafeBrowsingBlockHost) == 0 {
<mask> s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
<mask> }
<mask>
<mask> if s.conf.AsyncStartup {
<mask> params := dnsfilterCreatorParams{
<mask> conf: s.conf.Config,
<mask> filters: filters,
<mask> }
<mask> s.startCounter++
<mask> if s.startCounter == 1 {
<mask> s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
<mask> go s.dnsfilterCreator()
<mask> }
<mask>
<mask> // remove all pending tasks
<mask> stop := false
<mask> for !stop {
<mask> select {
<mask> case <-s.dnsfilterCreatorChan:
<mask> //
<mask> default:
<mask> stop = true
<mask> }
<mask> }
<mask>
<mask> s.dnsfilterCreatorChan <- params
<mask> } else {
<mask> log.Debug("creating dnsfilter...")
<mask> f := dnsfilter.New(&s.conf.Config, filters)
<mask> if f == nil {
<mask> return fmt.Errorf("could not initialize dnsfilter")
<mask> }
<mask> log.Debug("created dnsfilter")
<mask> s.dnsFilter = f
<mask> }
<mask> return nil
<mask> }
<mask>
<mask> func (s *Server) dnsfilterCreator() {
<mask> for {
<mask> params := <-s.dnsfilterCreatorChan
<mask>
<mask> s.Lock()
<mask> counter := s.startCounter
<mask> s.Unlock()
<mask>
<mask> log.Debug("creating dnsfilter...")
<mask> f := dnsfilter.New(¶ms.conf, params.filters)
<mask> if f == nil {
<mask> log.Error("could not initialize dnsfilter")
<mask> continue
<mask> }
<mask>
<mask> set := false
<mask> s.Lock()
<mask> if counter == s.startCounter {
<mask> s.dnsFilter = f
<mask> set = true
<mask> }
<mask> s.Unlock()
<mask> if set {
<mask> log.Debug("created and activated dnsfilter")
<mask> } else {
<mask> log.Debug("created dnsfilter")
<mask> }
<mask> }
<mask> }
<mask>
<mask> // Stop stops the DNS server
<mask> func (s *Server) Stop() error {
<mask> s.Lock()
<mask> defer s.Unlock()
<mask> return s.stopInternal()
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost </s> remove "Rewrite",
</s> add d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil </s> remove if s.dnsFilter != nil {
s.dnsFilter.Destroy()
s.dnsFilter = nil
}
</s> add </s> remove var err error
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
<mask> return errorx.Decorate(err, "could not stop the DNS server properly")
<mask> }
<mask> }
<mask>
<mask> if s.dnsFilter != nil {
<mask> s.dnsFilter.Destroy()
<mask> s.dnsFilter = nil
<mask> }
<mask>
<mask> return nil
<mask> }
<mask>
<mask> // IsRunning returns true if the DNS server is running
<mask> func (s *Server) IsRunning() bool {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove if s.dnsFilter != nil || s.dnsProxy != nil {
</s> add if s.dnsProxy != nil { </s> remove var res dnsfilter.Result
req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
dnsFilter := s.dnsFilter
</s> add </s> remove if !config.filteringStarted {
config.filteringStarted = true
startRefreshFilters()
}
</s> add </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
<mask> }
<mask>
<mask> // filterDNSRequest applies the dnsFilter and sets d.Res if the request was filtered
<mask> func (s *Server) filterDNSRequest(d *proxy.DNSContext) (*dnsfilter.Result, error) {
<mask> var res dnsfilter.Result
<mask> req := d.Req
<mask> host := strings.TrimSuffix(req.Question[0].Name, ".")
<mask>
<mask> dnsFilter := s.dnsFilter
<mask>
<mask> if !s.conf.ProtectionEnabled || s.dnsFilter == nil {
<mask> return &dnsfilter.Result{}, nil
<mask> }
<mask>
<mask> var err error
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove var err error
</s> add </s> remove res, err = dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts)
</s> add req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
res, err := s.dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts) </s> remove if s.dnsFilter != nil || s.dnsProxy != nil {
</s> add if s.dnsProxy != nil { </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove if s.dnsFilter != nil {
s.dnsFilter.Destroy()
s.dnsFilter = nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
<mask> if !s.conf.ProtectionEnabled || s.dnsFilter == nil {
<mask> return &dnsfilter.Result{}, nil
<mask> }
<mask>
<mask> var err error
<mask>
<mask> clientAddr := ""
<mask> if d.Addr != nil {
<mask> clientAddr, _, _ = net.SplitHostPort(d.Addr.String())
<mask> }
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove var res dnsfilter.Result
req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
dnsFilter := s.dnsFilter
</s> add </s> remove var setts dnsfilter.RequestFilteringSettings
</s> add setts := s.dnsFilter.GetConfig() </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost </s> remove if s.dnsFilter != nil || s.dnsProxy != nil {
</s> add if s.dnsProxy != nil { </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
setts := s.dnsFilter.GetConfig() | <mask> if d.Addr != nil {
<mask> clientAddr, _, _ = net.SplitHostPort(d.Addr.String())
<mask> }
<mask>
<mask> var setts dnsfilter.RequestFilteringSettings
<mask> setts.FilteringEnabled = true
<mask> setts.SafeSearchEnabled = s.conf.SafeSearchEnabled
<mask> setts.SafeBrowsingEnabled = s.conf.SafeBrowsingEnabled
<mask> setts.ParentalEnabled = s.conf.ParentalEnabled
<mask> if s.conf.FilterHandler != nil {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove setts.SafeSearchEnabled = s.conf.SafeSearchEnabled
setts.SafeBrowsingEnabled = s.conf.SafeBrowsingEnabled
setts.ParentalEnabled = s.conf.ParentalEnabled
</s> add </s> remove var err error
</s> add </s> remove s.conf.SafeSearchEnabled = true
</s> add </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
<mask> }
<mask>
<mask> var setts dnsfilter.RequestFilteringSettings
<mask> setts.FilteringEnabled = true
<mask> setts.SafeSearchEnabled = s.conf.SafeSearchEnabled
<mask> setts.SafeBrowsingEnabled = s.conf.SafeBrowsingEnabled
<mask> setts.ParentalEnabled = s.conf.ParentalEnabled
<mask> if s.conf.FilterHandler != nil {
<mask> s.conf.FilterHandler(clientAddr, &setts)
<mask> }
<mask>
<mask> res, err = dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove var setts dnsfilter.RequestFilteringSettings
</s> add setts := s.dnsFilter.GetConfig() </s> remove res, err = dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts)
</s> add req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
res, err := s.dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts) </s> remove s.conf.SafeSearchEnabled = true
</s> add </s> remove var err error
d.rulesStorage, err = urlfilter.NewRuleStorage(listArray)
</s> add rulesStorage, err := urlfilter.NewRuleStorage(listArray) </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go | |
req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
res, err := s.dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts) | <mask> if s.conf.FilterHandler != nil {
<mask> s.conf.FilterHandler(clientAddr, &setts)
<mask> }
<mask>
<mask> res, err = dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts)
<mask> if err != nil {
<mask> // Return immediately if there's an error
<mask> return nil, errorx.Decorate(err, "dnsfilter failed to check host '%s'", host)
<mask>
<mask> } else if res.IsFiltered {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove setts.SafeSearchEnabled = s.conf.SafeSearchEnabled
setts.SafeBrowsingEnabled = s.conf.SafeBrowsingEnabled
setts.ParentalEnabled = s.conf.ParentalEnabled
</s> add </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove if !config.filteringStarted {
config.filteringStarted = true
startRefreshFilters()
}
</s> add </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove if s.dnsFilter != nil || s.dnsProxy != nil {
</s> add if s.dnsProxy != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward.go |
<mask> }
<mask>
<mask> func TestSafeSearch(t *testing.T) {
<mask> s := createTestServer(t)
<mask> s.conf.SafeSearchEnabled = true
<mask> err := s.Start(nil)
<mask> if err != nil {
<mask> t.Fatalf("Failed to start server: %s", err)
<mask> }
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove if !config.filteringStarted {
config.filteringStarted = true
startRefreshFilters()
}
</s> add </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward_test.go | |
rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filters := map[int]string{}
filters[0] = rules
c := dnsfilter.Config{}
c.SafeBrowsingEnabled = true
c.SafeBrowsingCacheSize = 1000
c.SafeSearchEnabled = true
c.SafeSearchCacheSize = 1000
c.ParentalCacheSize = 1000
c.CacheTime = 30
f := dnsfilter.New(&c, filters)
s := NewServer(f, nil, nil) | <mask> }
<mask> }
<mask>
<mask> func createTestServer(t *testing.T) *Server {
<mask> s := NewServer(nil, nil)
<mask> s.conf.UDPListenAddr = &net.UDPAddr{Port: 0}
<mask> s.conf.TCPListenAddr = &net.TCPAddr{Port: 0}
<mask>
<mask> s.conf.FilteringConfig.FilteringEnabled = true
<mask> s.conf.FilteringConfig.ProtectionEnabled = true
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove s.conf.FilteringConfig.SafeBrowsingEnabled = true
s.conf.Filters = make([]dnsfilter.Filter, 0)
s.conf.SafeBrowsingCacheSize = 1000
s.conf.SafeSearchCacheSize = 1000
s.conf.ParentalCacheSize = 1000
s.conf.CacheTime = 30
rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filter := dnsfilter.Filter{ID: 0, Data: []byte(rules)}
s.conf.Filters = append(s.conf.Filters, filter)
</s> add </s> remove s.conf.SafeSearchEnabled = true
</s> add </s> remove func NewServer(stats stats.Stats, queryLog querylog.QueryLog) *Server {
</s> add func NewServer(dnsFilter *dnsfilter.Dnsfilter, stats stats.Stats, queryLog querylog.QueryLog) *Server { </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward_test.go |
<mask> s.conf.TCPListenAddr = &net.TCPAddr{Port: 0}
<mask>
<mask> s.conf.FilteringConfig.FilteringEnabled = true
<mask> s.conf.FilteringConfig.ProtectionEnabled = true
<mask> s.conf.FilteringConfig.SafeBrowsingEnabled = true
<mask> s.conf.Filters = make([]dnsfilter.Filter, 0)
<mask>
<mask> s.conf.SafeBrowsingCacheSize = 1000
<mask> s.conf.SafeSearchCacheSize = 1000
<mask> s.conf.ParentalCacheSize = 1000
<mask> s.conf.CacheTime = 30
<mask>
<mask> rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
<mask> filter := dnsfilter.Filter{ID: 0, Data: []byte(rules)}
<mask> s.conf.Filters = append(s.conf.Filters, filter)
<mask> return s
<mask> }
<mask>
<mask> func createServerTLSConfig(t *testing.T) (*tls.Config, []byte, []byte) {
<mask> privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove s := NewServer(nil, nil)
</s> add rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filters := map[int]string{}
filters[0] = rules
c := dnsfilter.Config{}
c.SafeBrowsingEnabled = true
c.SafeBrowsingCacheSize = 1000
c.SafeSearchEnabled = true
c.SafeSearchCacheSize = 1000
c.ParentalCacheSize = 1000
c.CacheTime = 30
f := dnsfilter.New(&c, filters)
s := NewServer(f, nil, nil) </s> remove s.conf.SafeSearchEnabled = true
</s> add </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove var setts dnsfilter.RequestFilteringSettings
</s> add setts := s.dnsFilter.GetConfig() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | dnsforward/dnsforward_test.go | |
"github.com/AdguardTeam/AdGuardHome/dnsfilter" | <mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/AdguardTeam/AdGuardHome/dhcpd"
<mask> "github.com/AdguardTeam/AdGuardHome/dnsforward"
<mask> "github.com/AdguardTeam/AdGuardHome/querylog"
<mask> "github.com/AdguardTeam/AdGuardHome/stats"
<mask> "github.com/AdguardTeam/golibs/file"
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove "fmt"
</s> add </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/config.go |
<mask> transport *http.Transport
<mask> client *http.Client
<mask> stats stats.Stats // statistics module
<mask> queryLog querylog.QueryLog // query log module
<mask> filteringStarted bool // TRUE if filtering module is started
<mask> auth *Auth // HTTP authentication module
<mask>
<mask> // cached version.json to avoid hammering github.io for each page reload
<mask> versionCheckJSON []byte
<mask> versionCheckLastTime time.Time
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // How many times the server was started
// While creating a dnsfilter object,
// we use this value to set s.dnsFilter property only with the most recent settings.
startCounter uint32
dnsfilterCreatorChan chan dnsfilterCreatorParams
</s> add </s> remove Config // for direct access by library users, even a = assignment
privateConfig
</s> add parentalServer string // access via methods
safeBrowsingServer string // access via methods
Config // for direct access by library users, even a = assignment
confLock sync.RWMutex
// Channel for passing data to filters-initializer goroutine
filtersInitializerChan chan filtersInitializerParams
filtersInitializerLock sync.Mutex </s> remove //go:generate stringer -type=Reason
</s> add </s> remove ResolverAddress string // DNS server address
</s> add ResolverAddress string `yaml:"-"` // DNS server address | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/config.go | |
dnsFilter *dnsfilter.Dnsfilter | <mask> versionCheckLastTime time.Time
<mask>
<mask> dnsctx dnsContext
<mask> dnsServer *dnsforward.Server
<mask> dhcpServer dhcpd.Server
<mask> httpServer *http.Server
<mask> httpsServer HTTPSServer
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove filteringStarted bool // TRUE if filtering module is started
</s> add </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/config.go |
config.DNS.DnsfilterConf.SafeBrowsingCacheSize = 1 * 1024 * 1024
config.DNS.DnsfilterConf.SafeSearchCacheSize = 1 * 1024 * 1024
config.DNS.DnsfilterConf.ParentalCacheSize = 1 * 1024 * 1024
config.DNS.DnsfilterConf.CacheTime = 30 | <mask> config.DNS.UpstreamDNS = defaultDNS
<mask> }
<mask>
<mask> config.DNS.CacheSize = 4 * 1024 * 1024
<mask> config.DNS.SafeBrowsingCacheSize = 1 * 1024 * 1024
<mask> config.DNS.SafeSearchCacheSize = 1 * 1024 * 1024
<mask> config.DNS.ParentalCacheSize = 1 * 1024 * 1024
<mask> config.DNS.CacheTime = 30
<mask> config.Filters = defaultFilters()
<mask> }
<mask>
<mask> // getConfigFilename returns path to the current config file
<mask> func (c *configuration) getConfigFilename() string {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove refreshFiltersIfNecessary(false)
</s> add if config.DNS.FiltersUpdateIntervalHours != 0 && nextRefresh <= time.Now().Unix() {
_ = refreshFiltersIfNecessary(false)
nextRefresh = time.Now().Add(1 * time.Hour).Unix()
}
time.Sleep(1 * time.Second) </s> remove time.Sleep(1 * time.Hour)
if config.DNS.FiltersUpdateIntervalHours == 0 {
continue
</s> add if forceRefresh {
_ = refreshFiltersIfNecessary(true)
forceRefresh = false </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove "Rewrite",
</s> add d.filtersInitializerLock.Lock() // prevent multiple writers from adding more than 1 task
// remove all pending tasks
stop := false
for !stop {
select {
case <-d.filtersInitializerChan:
//
default:
stop = true
}
}
d.filtersInitializerChan <- params
d.filtersInitializerLock.Unlock()
return nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/config.go |
if config.dnsFilter != nil {
c := dnsfilter.Config{}
config.dnsFilter.WriteDiskConfig(&c)
config.DNS.DnsfilterConf = c
}
| <mask> config.DNS.QueryLogEnabled = dc.Enabled
<mask> config.DNS.QueryLogInterval = dc.Interval
<mask> }
<mask>
<mask> configFile := config.getConfigFilename()
<mask> log.Debug("Writing YAML file: %s", configFile)
<mask> yamlText, err := yaml.Marshal(&config)
<mask> config.Clients = nil
<mask> if err != nil {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove var err error
d.rulesStorage, err = urlfilter.NewRuleStorage(listArray)
</s> add rulesStorage, err := urlfilter.NewRuleStorage(listArray) </s> remove s.conf.SafeSearchEnabled = true
</s> add </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/config.go |
<mask> log.Debug("DNS %s works OK", input)
<mask> return nil
<mask> }
<mask>
<mask> // ------------
<mask> // safebrowsing
<mask> // ------------
<mask>
<mask> func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
<mask> config.DNS.SafeBrowsingEnabled = true
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
<mask> config.DNS.SafeBrowsingEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
<mask> data := map[string]interface{}{
<mask> "enabled": config.DNS.SafeBrowsingEnabled,
<mask> }
<mask> jsonVal, err := json.Marshal(data)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
<mask> }
<mask>
<mask> w.Header().Set("Content-Type", "application/json")
<mask> _, err = w.Write(jsonVal)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
<mask> return
<mask> }
<mask> }
<mask>
<mask> // --------
<mask> // parental
<mask> // --------
<mask> func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
<mask> parameters, err := parseParametersFromBody(r.Body)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
<mask> return
<mask> }
<mask>
<mask> sensitivity, ok := parameters["sensitivity"]
<mask> if !ok {
<mask> http.Error(w, "Sensitivity parameter was not specified", 400)
<mask> return
<mask> }
<mask>
<mask> switch sensitivity {
<mask> case "3":
<mask> break
<mask> case "EARLY_CHILDHOOD":
<mask> sensitivity = "3"
<mask> case "10":
<mask> break
<mask> case "YOUNG":
<mask> sensitivity = "10"
<mask> case "13":
<mask> break
<mask> case "TEEN":
<mask> sensitivity = "13"
<mask> case "17":
<mask> break
<mask> case "MATURE":
<mask> sensitivity = "17"
<mask> default:
<mask> http.Error(w, "Sensitivity must be set to valid value", 400)
<mask> return
<mask> }
<mask> i, err := strconv.Atoi(sensitivity)
<mask> if err != nil {
<mask> http.Error(w, "Sensitivity must be set to valid value", 400)
<mask> return
<mask> }
<mask> config.DNS.ParentalSensitivity = i
<mask> config.DNS.ParentalEnabled = true
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
<mask> config.DNS.ParentalEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
<mask> data := map[string]interface{}{
<mask> "enabled": config.DNS.ParentalEnabled,
<mask> }
<mask> if config.DNS.ParentalEnabled {
<mask> data["sensitivity"] = config.DNS.ParentalSensitivity
<mask> }
<mask> jsonVal, err := json.Marshal(data)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
<mask> return
<mask> }
<mask>
<mask> w.Header().Set("Content-Type", "application/json")
<mask> _, err = w.Write(jsonVal)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
<mask> return
<mask> }
<mask> }
<mask>
<mask> // ------------
<mask> // safebrowsing
<mask> // ------------
<mask>
<mask> func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
<mask> config.DNS.SafeSearchEnabled = true
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
<mask> config.DNS.SafeSearchEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
<mask> data := map[string]interface{}{
<mask> "enabled": config.DNS.SafeSearchEnabled,
<mask> }
<mask> jsonVal, err := json.Marshal(data)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
<mask> return
<mask> }
<mask>
<mask> w.Header().Set("Content-Type", "application/json")
<mask> _, err = w.Write(jsonVal)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
<mask> return
<mask> }
<mask> }
<mask>
<mask> // --------------
<mask> // DNS-over-HTTPS
<mask> // --------------
<mask> func handleDOH(w http.ResponseWriter, r *http.Request) {
<mask> if r.TLS == nil {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add onConfigModified()
enableFilters(true) </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add _ = writeAllConfigs()
enableFilters(true) </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
</s> add beginRefreshFilters()
fmt.Fprintf(w, "OK 0 filters updated\n") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control.go | |
<mask> httpRegister(http.MethodPost, "/control/i18n/change_language", handleI18nChangeLanguage)
<mask> httpRegister(http.MethodGet, "/control/i18n/current_language", handleI18nCurrentLanguage)
<mask> http.HandleFunc("/control/version.json", postInstall(optionalAuth(handleGetVersionJSON)))
<mask> httpRegister(http.MethodPost, "/control/update", handleUpdate)
<mask> httpRegister(http.MethodPost, "/control/safebrowsing/enable", handleSafeBrowsingEnable)
<mask> httpRegister(http.MethodPost, "/control/safebrowsing/disable", handleSafeBrowsingDisable)
<mask> httpRegister(http.MethodGet, "/control/safebrowsing/status", handleSafeBrowsingStatus)
<mask> httpRegister(http.MethodPost, "/control/parental/enable", handleParentalEnable)
<mask> httpRegister(http.MethodPost, "/control/parental/disable", handleParentalDisable)
<mask> httpRegister(http.MethodGet, "/control/parental/status", handleParentalStatus)
<mask> httpRegister(http.MethodPost, "/control/safesearch/enable", handleSafeSearchEnable)
<mask> httpRegister(http.MethodPost, "/control/safesearch/disable", handleSafeSearchDisable)
<mask> httpRegister(http.MethodGet, "/control/safesearch/status", handleSafeSearchStatus)
<mask> httpRegister(http.MethodGet, "/control/dhcp/status", handleDHCPStatus)
<mask> httpRegister(http.MethodGet, "/control/dhcp/interfaces", handleDHCPInterfaces)
<mask> httpRegister(http.MethodPost, "/control/dhcp/set_config", handleDHCPSetConfig)
<mask> httpRegister(http.MethodPost, "/control/dhcp/find_active_dhcp", handleDHCPFindActiveServer)
<mask> httpRegister(http.MethodPost, "/control/dhcp/add_static_lease", handleDHCPAddStaticLease)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
returnOK(w)
</s> add onConfigModified()
enableFilters(true) </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() </s> remove defer d.Destroy()
</s> add defer d.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control.go | |
<mask>
<mask> RegisterFilteringHandlers()
<mask> RegisterTLSHandlers()
<mask> RegisterClientsHandlers()
<mask> registerRewritesHandlers()
<mask> RegisterBlockedServicesHandlers()
<mask> RegisterAuthHandlers()
<mask>
<mask> http.HandleFunc("/dns-query", postInstall(handleDOH))
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
returnOK(w)
</s> add onConfigModified()
enableFilters(true) </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control.go | |
onConfigModified()
enableFilters(true) | <mask> httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
<mask> return
<mask> }
<mask>
<mask> err = writeAllConfigs()
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
<mask> return
<mask> }
<mask>
<mask> err = reconfigureDNSServer()
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
<mask> return
<mask> }
<mask>
<mask> _, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add </s> remove log.Debug("os.Remove(%s)", filter.Path())
</s> add </s> remove if !config.filteringStarted {
config.filteringStarted = true
startRefreshFilters()
}
</s> add </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go |
<mask> http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> // Stop DNS server:
<mask> // we close urlfilter object which in turn closes file descriptors to filter files.
<mask> // Otherwise, Windows won't allow us to remove the file which is being currently used.
<mask> _ = config.dnsServer.Stop()
<mask>
<mask> // go through each element and delete if url matches
<mask> config.Lock()
<mask> newFilters := config.Filters[:0]
<mask> for _, filter := range config.Filters {
<mask> if filter.URL != req.URL {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove newFilters := config.Filters[:0]
</s> add newFilters := []filter{} </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove // . If filter data has changed, save it on disk
// . Apply changes to the current configuration
// . Start server
</s> add // . If filter data has changed: rename the old file, store the new data on disk
// . Pass new filters to dnsfilter object </s> remove // Create dnsfilter asynchronously.
// Requests won't be filtered until dnsfilter is created.
// If "restart" command is received while we're creating an old dnsfilter object,
// we delay creation of the new object until the old one is created.
AsyncStartup bool `yaml:"-"`
</s> add // Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go | |
newFilters := []filter{} | <mask> _ = config.dnsServer.Stop()
<mask>
<mask> // go through each element and delete if url matches
<mask> config.Lock()
<mask> newFilters := config.Filters[:0]
<mask> for _, filter := range config.Filters {
<mask> if filter.URL != req.URL {
<mask> newFilters = append(newFilters, filter)
<mask> } else {
<mask> // Remove the filter file
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Stop DNS server:
// we close urlfilter object which in turn closes file descriptors to filter files.
// Otherwise, Windows won't allow us to remove the file which is being currently used.
_ = config.dnsServer.Stop()
</s> add </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add </s> remove updateCount = 0
</s> add updateCount := 0 </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go |
err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) | <mask> for _, filter := range config.Filters {
<mask> if filter.URL != req.URL {
<mask> newFilters = append(newFilters, filter)
<mask> } else {
<mask> // Remove the filter file
<mask> err := os.Remove(filter.Path())
<mask> if err != nil && !os.IsNotExist(err) {
<mask> config.Unlock()
<mask> httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
<mask> return
<mask> }
<mask> log.Debug("os.Remove(%s)", filter.Path())
<mask> }
<mask> }
<mask> // Update the configuration after removing filter files
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove log.Debug("os.Remove(%s)", filter.Path())
</s> add </s> remove newFilters := config.Filters[:0]
</s> add newFilters := []filter{} </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add onConfigModified()
enableFilters(true)
// Note: the old files "filter.txt.old" aren't deleted - it's not really necessary,
// but will require the additional code to run after enableFilters() is finished: i.e. complicated </s> remove // Stop DNS server:
// we close urlfilter object which in turn closes file descriptors to filter files.
// Otherwise, Windows won't allow us to remove the file which is being currently used.
_ = config.dnsServer.Stop()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go |
<mask> config.Unlock()
<mask> httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
<mask> return
<mask> }
<mask> log.Debug("os.Remove(%s)", filter.Path())
<mask> }
<mask> }
<mask> // Update the configuration after removing filter files
<mask> config.Filters = newFilters
<mask> config.Unlock()
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add onConfigModified()
enableFilters(true)
// Note: the old files "filter.txt.old" aren't deleted - it's not really necessary,
// but will require the additional code to run after enableFilters() is finished: i.e. complicated </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove newFilters := config.Filters[:0]
</s> add newFilters := []filter{} </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go | |
onConfigModified()
enableFilters(true)
// Note: the old files "filter.txt.old" aren't deleted - it's not really necessary,
// but will require the additional code to run after enableFilters() is finished: i.e. complicated | <mask> }
<mask> // Update the configuration after removing filter files
<mask> config.Filters = newFilters
<mask> config.Unlock()
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> type filterURLJSON struct {
<mask> URL string `json:"url"`
<mask> Enabled bool `json:"enabled"`
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove log.Debug("os.Remove(%s)", filter.Path())
</s> add </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
</s> add beginRefreshFilters()
fmt.Fprintf(w, "OK 0 filters updated\n") </s> remove newFilters := config.Filters[:0]
</s> add newFilters := []filter{} </s> remove // Filtering callback function
FilterHandler func(clientAddr string, settings *RequestFilteringSettings) `yaml:"-"`
}
</s> add // Called when the configuration is changed by HTTP request
ConfigModified func() `yaml:"-"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go |
onConfigModified()
enableFilters(true) | <mask> http.Error(w, "URL doesn't exist", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
<mask> body, err := ioutil.ReadAll(r.Body)
<mask> if err != nil {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add _ = writeAllConfigs()
enableFilters(true) </s> remove updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
</s> add beginRefreshFilters()
fmt.Fprintf(w, "OK 0 filters updated\n") </s> remove // Stop DNS server:
// we close urlfilter object which in turn closes file descriptors to filter files.
// Otherwise, Windows won't allow us to remove the file which is being currently used.
_ = config.dnsServer.Stop()
</s> add </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go |
_ = writeAllConfigs()
enableFilters(true) | <mask> return
<mask> }
<mask>
<mask> config.UserRules = strings.Split(string(body), "\n")
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
<mask> updated := refreshFiltersIfNecessary(true)
<mask> fmt.Fprintf(w, "OK %d filters updated\n", updated)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
</s> add beginRefreshFilters()
fmt.Fprintf(w, "OK 0 filters updated\n") </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add onConfigModified()
enableFilters(true) </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
returnOK(w)
</s> add onConfigModified()
enableFilters(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go |
beginRefreshFilters()
fmt.Fprintf(w, "OK 0 filters updated\n") | <mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
<mask> updated := refreshFiltersIfNecessary(true)
<mask> fmt.Fprintf(w, "OK %d filters updated\n", updated)
<mask> }
<mask>
<mask> type filterJSON struct {
<mask> ID int64 `json:"id"`
<mask> Enabled bool `json:"enabled"`
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add _ = writeAllConfigs()
enableFilters(true) </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add onConfigModified()
enableFilters(true) </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add onConfigModified()
enableFilters(true)
// Note: the old files "filter.txt.old" aren't deleted - it's not really necessary,
// but will require the additional code to run after enableFilters() is finished: i.e. complicated </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go |
onConfigModified()
enableFilters(true) | <mask> }
<mask>
<mask> config.DNS.FilteringEnabled = req.Enabled
<mask> config.DNS.FiltersUpdateIntervalHours = req.Interval
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask>
<mask> returnOK(w)
<mask> }
<mask>
<mask> // RegisterFilteringHandlers - register handlers
<mask> func RegisterFilteringHandlers() {
<mask> httpRegister(http.MethodGet, "/control/filtering_info", handleFilteringInfo)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // ------------
// safebrowsing
// ------------
func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeBrowsingEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeBrowsingEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// --------
// parental
// --------
func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
sensitivity, ok := parameters["sensitivity"]
if !ok {
http.Error(w, "Sensitivity parameter was not specified", 400)
return
}
switch sensitivity {
case "3":
break
case "EARLY_CHILDHOOD":
sensitivity = "3"
case "10":
break
case "YOUNG":
sensitivity = "10"
case "13":
break
case "TEEN":
sensitivity = "13"
case "17":
break
case "MATURE":
sensitivity = "17"
default:
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
i, err := strconv.Atoi(sensitivity)
if err != nil {
http.Error(w, "Sensitivity must be set to valid value", 400)
return
}
config.DNS.ParentalSensitivity = i
config.DNS.ParentalEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.ParentalEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.ParentalEnabled,
}
if config.DNS.ParentalEnabled {
data["sensitivity"] = config.DNS.ParentalSensitivity
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
// ------------
// safebrowsing
// ------------
func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
config.DNS.SafeSearchEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
data := map[string]interface{}{
"enabled": config.DNS.SafeSearchEnabled,
}
jsonVal, err := json.Marshal(data)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(jsonVal)
if err != nil {
httpError(w, http.StatusInternalServerError, "Unable to write response json: %s", err)
return
}
}
</s> add </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add onConfigModified()
enableFilters(true)
// Note: the old files "filter.txt.old" aren't deleted - it's not really necessary,
// but will require the additional code to run after enableFilters() is finished: i.e. complicated </s> remove httpUpdateConfigReloadDNSReturnOK(w, r)
</s> add _ = writeAllConfigs()
enableFilters(true) </s> remove refreshFiltersIfNecessary(false)
</s> add if config.DNS.FiltersUpdateIntervalHours != 0 && nextRefresh <= time.Now().Unix() {
_ = refreshFiltersIfNecessary(false)
nextRefresh = time.Now().Add(1 * time.Hour).Unix()
}
time.Sleep(1 * time.Second) </s> remove names := []string{
"NotFilteredNotFound",
"NotFilteredWhiteList",
"NotFilteredError",
</s> add if uint(r) >= uint(len(reasonNames)) {
return ""
}
return reasonNames[r]
}
// GetConfig - get configuration
func (d *Dnsfilter) GetConfig() RequestFilteringSettings {
c := RequestFilteringSettings{}
// d.confLock.RLock()
c.SafeSearchEnabled = d.Config.SafeSearchEnabled
c.SafeBrowsingEnabled = d.Config.SafeBrowsingEnabled
c.ParentalEnabled = d.Config.ParentalEnabled
// d.confLock.RUnlock()
return c
}
// WriteDiskConfig - write configuration
func (d *Dnsfilter) WriteDiskConfig(c *Config) {
*c = d.Config
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/control_filtering.go |
filterConf := config.DNS.DnsfilterConf
bindhost := config.DNS.BindHost
if config.DNS.BindHost == "0.0.0.0" {
bindhost = "127.0.0.1"
}
filterConf.ResolverAddress = fmt.Sprintf("%s:%d", bindhost, config.DNS.Port)
filterConf.ConfigModified = onConfigModified
filterConf.HTTPRegister = httpRegister
config.dnsFilter = dnsfilter.New(&filterConf, nil)
config.dnsServer = dnsforward.NewServer(config.dnsFilter, config.stats, config.queryLog) | <mask> ConfigModified: onConfigModified,
<mask> HTTPRegister: httpRegister,
<mask> }
<mask> config.queryLog = querylog.New(conf)
<mask> config.dnsServer = dnsforward.NewServer(config.stats, config.queryLog)
<mask>
<mask> sessFilename := filepath.Join(baseDir, "sessions.db")
<mask> config.auth = InitAuth(sessFilename, config.Users)
<mask> config.Users = nil
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove s := NewServer(nil, nil)
</s> add rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filters := map[int]string{}
filters[0] = rules
c := dnsfilter.Config{}
c.SafeBrowsingEnabled = true
c.SafeBrowsingCacheSize = 1000
c.SafeSearchEnabled = true
c.SafeSearchCacheSize = 1000
c.ParentalCacheSize = 1000
c.CacheTime = 30
f := dnsfilter.New(&c, filters)
s := NewServer(f, nil, nil) </s> remove var setts dnsfilter.RequestFilteringSettings
</s> add setts := s.dnsFilter.GetConfig() </s> remove var err error
d.rulesStorage, err = urlfilter.NewRuleStorage(listArray)
</s> add rulesStorage, err := urlfilter.NewRuleStorage(listArray) </s> remove s.conf.FilteringConfig.SafeBrowsingEnabled = true
s.conf.Filters = make([]dnsfilter.Filter, 0)
s.conf.SafeBrowsingCacheSize = 1000
s.conf.SafeSearchCacheSize = 1000
s.conf.ParentalCacheSize = 1000
s.conf.CacheTime = 30
rules := "||nxdomain.example.org^\n||null.example.org^\n127.0.0.1 host.example.org\n"
filter := dnsfilter.Filter{ID: 0, Data: []byte(rules)}
s.conf.Filters = append(s.conf.Filters, filter)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/dns.go |
<mask> }
<mask> }
<mask>
<mask> func generateServerConfig() (dnsforward.ServerConfig, error) {
<mask> filters := []dnsfilter.Filter{}
<mask> userFilter := userFilter()
<mask> filters = append(filters, dnsfilter.Filter{
<mask> ID: userFilter.ID,
<mask> Data: userFilter.Data,
<mask> })
<mask> for _, filter := range config.Filters {
<mask> if !filter.Enabled {
<mask> continue
<mask> }
<mask> filters = append(filters, dnsfilter.Filter{
<mask> ID: filter.ID,
<mask> FilePath: filter.Path(),
<mask> })
<mask> }
<mask>
<mask> newconfig := dnsforward.ServerConfig{
<mask> UDPListenAddr: &net.UDPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.DNS.Port},
<mask> TCPListenAddr: &net.TCPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.DNS.Port},
<mask> FilteringConfig: config.DNS.FilteringConfig,
<mask> Filters: filters,
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove Filters: filters,
</s> add </s> remove newconfig.AsyncStartup = true
bindhost := config.DNS.BindHost
if config.DNS.BindHost == "0.0.0.0" {
bindhost = "127.0.0.1"
}
newconfig.ResolverAddress = fmt.Sprintf("%s:%d", bindhost, config.DNS.Port)
</s> add </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/dns.go | |
<mask> newconfig := dnsforward.ServerConfig{
<mask> UDPListenAddr: &net.UDPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.DNS.Port},
<mask> TCPListenAddr: &net.TCPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.DNS.Port},
<mask> FilteringConfig: config.DNS.FilteringConfig,
<mask> Filters: filters,
<mask> }
<mask> newconfig.AsyncStartup = true
<mask> bindhost := config.DNS.BindHost
<mask> if config.DNS.BindHost == "0.0.0.0" {
<mask> bindhost = "127.0.0.1"
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove newconfig.AsyncStartup = true
bindhost := config.DNS.BindHost
if config.DNS.BindHost == "0.0.0.0" {
bindhost = "127.0.0.1"
}
newconfig.ResolverAddress = fmt.Sprintf("%s:%d", bindhost, config.DNS.Port)
</s> add </s> remove filters := []dnsfilter.Filter{}
userFilter := userFilter()
filters = append(filters, dnsfilter.Filter{
ID: userFilter.ID,
Data: userFilter.Data,
})
for _, filter := range config.Filters {
if !filter.Enabled {
continue
}
filters = append(filters, dnsfilter.Filter{
ID: filter.ID,
FilePath: filter.Path(),
})
}
</s> add </s> remove config.dnsServer = dnsforward.NewServer(config.stats, config.queryLog)
</s> add filterConf := config.DNS.DnsfilterConf
bindhost := config.DNS.BindHost
if config.DNS.BindHost == "0.0.0.0" {
bindhost = "127.0.0.1"
}
filterConf.ResolverAddress = fmt.Sprintf("%s:%d", bindhost, config.DNS.Port)
filterConf.ConfigModified = onConfigModified
filterConf.HTTPRegister = httpRegister
config.dnsFilter = dnsfilter.New(&filterConf, nil)
config.dnsServer = dnsforward.NewServer(config.dnsFilter, config.stats, config.queryLog) </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/dns.go | |
<mask> TCPListenAddr: &net.TCPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.DNS.Port},
<mask> FilteringConfig: config.DNS.FilteringConfig,
<mask> Filters: filters,
<mask> }
<mask> newconfig.AsyncStartup = true
<mask> bindhost := config.DNS.BindHost
<mask> if config.DNS.BindHost == "0.0.0.0" {
<mask> bindhost = "127.0.0.1"
<mask> }
<mask> newconfig.ResolverAddress = fmt.Sprintf("%s:%d", bindhost, config.DNS.Port)
<mask>
<mask> if config.TLS.Enabled {
<mask> newconfig.TLSConfig = config.TLS.TLSConfig
<mask> if config.TLS.PortDNSOverTLS != 0 {
<mask> newconfig.TLSListenAddr = &net.TCPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.TLS.PortDNSOverTLS}
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove Filters: filters,
</s> add </s> remove filters := []dnsfilter.Filter{}
userFilter := userFilter()
filters = append(filters, dnsfilter.Filter{
ID: userFilter.ID,
Data: userFilter.Data,
})
for _, filter := range config.Filters {
if !filter.Enabled {
continue
}
filters = append(filters, dnsfilter.Filter{
ID: filter.ID,
FilePath: filter.Path(),
})
}
</s> add </s> remove config.dnsServer = dnsforward.NewServer(config.stats, config.queryLog)
</s> add filterConf := config.DNS.DnsfilterConf
bindhost := config.DNS.BindHost
if config.DNS.BindHost == "0.0.0.0" {
bindhost = "127.0.0.1"
}
filterConf.ResolverAddress = fmt.Sprintf("%s:%d", bindhost, config.DNS.Port)
filterConf.ConfigModified = onConfigModified
filterConf.HTTPRegister = httpRegister
config.dnsFilter = dnsfilter.New(&filterConf, nil)
config.dnsServer = dnsforward.NewServer(config.dnsFilter, config.stats, config.queryLog) </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/dns.go | |
enableFilters(false)
| <mask> }
<mask>
<mask> newconfig, err := generateServerConfig()
<mask> if err != nil {
<mask> return errorx.Decorate(err, "Couldn't start forwarding DNS server")
<mask> }
<mask>
<mask> err = config.dnsServer.Start(&newconfig)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove if !config.filteringStarted {
config.filteringStarted = true
startRefreshFilters()
}
</s> add </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove s.conf.SafeSearchEnabled = true
</s> add </s> remove res, err = dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts)
</s> add req := d.Req
host := strings.TrimSuffix(req.Question[0].Name, ".")
res, err := s.dnsFilter.CheckHost(host, d.Req.Question[0].Qtype, &setts) </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/dns.go |
<mask> if err != nil {
<mask> return errorx.Decorate(err, "Couldn't start forwarding DNS server")
<mask> }
<mask>
<mask> if !config.filteringStarted {
<mask> config.filteringStarted = true
<mask> startRefreshFilters()
<mask> }
<mask>
<mask> return nil
<mask> }
<mask>
<mask> func reconfigureDNSServer() error {
<mask> newconfig, err := generateServerConfig()
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") </s> remove if s.dnsFilter != nil {
s.dnsFilter.Destroy()
s.dnsFilter = nil
}
</s> add </s> remove s.conf.SafeSearchEnabled = true
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/dns.go | |
config.dnsFilter.Close()
config.dnsFilter = nil
| <mask> config.dnsServer.Close()
<mask>
<mask> config.stats.Close()
<mask> config.stats = nil
<mask>
<mask> config.queryLog.Close()
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove var setts dnsfilter.RequestFilteringSettings
</s> add setts := s.dnsFilter.GetConfig() </s> remove
err = startDNSServer()
if err != nil {
log.Fatal(err)
}
</s> add go func() {
err = startDNSServer()
if err != nil {
log.Fatal(err)
}
}() </s> remove setts.SafeSearchEnabled = s.conf.SafeSearchEnabled
setts.SafeBrowsingEnabled = s.conf.SafeBrowsingEnabled
setts.ParentalEnabled = s.conf.ParentalEnabled
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/dns.go |
forceRefresh bool | <mask> var (
<mask> nextFilterID = time.Now().Unix() // semi-stable way to generate an unique ID
<mask> filterTitleRegexp = regexp.MustCompile(`^! Title: +(.*)$`)
<mask> )
<mask>
<mask> func initFiltering() {
<mask> loadFilters()
<mask> deduplicateFilters()
<mask> updateUniqueFilterID(config.Filters)
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove }
func startRefreshFilters() {
go func() {
_ = refreshFiltersIfNecessary(false)
}()
</s> add </s> remove names := []string{
"NotFilteredNotFound",
"NotFilteredWhiteList",
"NotFilteredError",
</s> add if uint(r) >= uint(len(reasonNames)) {
return ""
}
return reasonNames[r]
}
// GetConfig - get configuration
func (d *Dnsfilter) GetConfig() RequestFilteringSettings {
c := RequestFilteringSettings{}
// d.confLock.RLock()
c.SafeSearchEnabled = d.Config.SafeSearchEnabled
c.SafeBrowsingEnabled = d.Config.SafeBrowsingEnabled
c.ParentalEnabled = d.Config.ParentalEnabled
// d.confLock.RUnlock()
return c
}
// WriteDiskConfig - write configuration
func (d *Dnsfilter) WriteDiskConfig(c *Config) {
*c = d.Config
} </s> remove refreshFiltersIfNecessary(false)
</s> add if config.DNS.FiltersUpdateIntervalHours != 0 && nextRefresh <= time.Now().Unix() {
_ = refreshFiltersIfNecessary(false)
nextRefresh = time.Now().Add(1 * time.Hour).Unix()
}
time.Sleep(1 * time.Second) </s> remove d.filteringEngine = urlfilter.NewDNSEngine(d.rulesStorage)
</s> add filteringEngine := urlfilter.NewDNSEngine(rulesStorage)
d.engineLock.Lock()
if d.rulesStorage != nil {
d.rulesStorage.Close()
}
d.rulesStorage = rulesStorage
d.filteringEngine = filteringEngine
d.engineLock.Unlock()
log.Debug("initialized filtering engine")
| [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
<mask> func initFiltering() {
<mask> loadFilters()
<mask> deduplicateFilters()
<mask> updateUniqueFilterID(config.Filters)
<mask> }
<mask>
<mask> func startRefreshFilters() {
<mask> go func() {
<mask> _ = refreshFiltersIfNecessary(false)
<mask> }()
<mask> go periodicallyRefreshFilters()
<mask> }
<mask>
<mask> func defaultFilters() []filter {
<mask> return []filter{
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove
err = startDNSServer()
if err != nil {
log.Fatal(err)
}
</s> add go func() {
err = startDNSServer()
if err != nil {
log.Fatal(err)
}
}() </s> remove time.Sleep(1 * time.Hour)
if config.DNS.FiltersUpdateIntervalHours == 0 {
continue
</s> add if forceRefresh {
_ = refreshFiltersIfNecessary(true)
forceRefresh = false </s> remove newFilters := config.Filters[:0]
</s> add newFilters := []filter{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go | |
nextRefresh := int64(0) | <mask> }
<mask>
<mask> // Sets up a timer that will be checking for filters updates periodically
<mask> func periodicallyRefreshFilters() {
<mask> for {
<mask> if forceRefresh {
<mask> _ = refreshFiltersIfNecessary(true)
<mask> forceRefresh = false
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove time.Sleep(1 * time.Hour)
if config.DNS.FiltersUpdateIntervalHours == 0 {
continue
</s> add if forceRefresh {
_ = refreshFiltersIfNecessary(true)
forceRefresh = false </s> remove refreshFiltersIfNecessary(false)
</s> add if config.DNS.FiltersUpdateIntervalHours != 0 && nextRefresh <= time.Now().Unix() {
_ = refreshFiltersIfNecessary(false)
nextRefresh = time.Now().Add(1 * time.Hour).Unix()
}
time.Sleep(1 * time.Second) </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
if forceRefresh {
_ = refreshFiltersIfNecessary(true)
forceRefresh = false | <mask>
<mask> // Sets up a timer that will be checking for filters updates periodically
<mask> func periodicallyRefreshFilters() {
<mask> for {
<mask> time.Sleep(1 * time.Hour)
<mask> if config.DNS.FiltersUpdateIntervalHours == 0 {
<mask> continue
<mask> }
<mask>
<mask> refreshFiltersIfNecessary(false)
<mask> }
<mask> }
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove refreshFiltersIfNecessary(false)
</s> add if config.DNS.FiltersUpdateIntervalHours != 0 && nextRefresh <= time.Now().Unix() {
_ = refreshFiltersIfNecessary(false)
nextRefresh = time.Now().Add(1 * time.Hour).Unix()
}
time.Sleep(1 * time.Second) </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove }
func startRefreshFilters() {
go func() {
_ = refreshFiltersIfNecessary(false)
}()
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
if config.DNS.FiltersUpdateIntervalHours != 0 && nextRefresh <= time.Now().Unix() {
_ = refreshFiltersIfNecessary(false)
nextRefresh = time.Now().Add(1 * time.Hour).Unix()
}
time.Sleep(1 * time.Second) | <mask> if config.DNS.FiltersUpdateIntervalHours == 0 {
<mask> continue
<mask> }
<mask>
<mask> refreshFiltersIfNecessary(false)
<mask> }
<mask> }
<mask>
<mask> // Checks filters updates if necessary
<mask> // If force is true, it ignores the filter.LastUpdated field value
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove time.Sleep(1 * time.Hour)
if config.DNS.FiltersUpdateIntervalHours == 0 {
continue
</s> add if forceRefresh {
_ = refreshFiltersIfNecessary(true)
forceRefresh = false </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add </s> remove // Saving it to the filters dir now
err := uf.save()
</s> add err := uf.saveAndBackupOld() </s> remove updateCount = 0
</s> add updateCount := 0 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
// Schedule the procedure to refresh filters
func beginRefreshFilters() {
forceRefresh = true
log.Debug("Filters: schedule update")
}
| <mask> time.Sleep(1 * time.Second)
<mask> }
<mask> }
<mask>
<mask> // Checks filters updates if necessary
<mask> // If force is true, it ignores the filter.LastUpdated field value
<mask> //
<mask> // Algorithm:
<mask> // . Get the list of filters to be updated
<mask> // . For each filter run the download and checksum check operation
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // . Stop server
</s> add </s> remove refreshFiltersIfNecessary(false)
</s> add if config.DNS.FiltersUpdateIntervalHours != 0 && nextRefresh <= time.Now().Unix() {
_ = refreshFiltersIfNecessary(false)
nextRefresh = time.Now().Add(1 * time.Hour).Unix()
}
time.Sleep(1 * time.Second) </s> remove // . If filter data has changed, save it on disk
// . Apply changes to the current configuration
// . Start server
</s> add // . If filter data has changed: rename the old file, store the new data on disk
// . Pass new filters to dnsfilter object </s> remove // Create dnsfilter asynchronously.
// Requests won't be filtered until dnsfilter is created.
// If "restart" command is received while we're creating an old dnsfilter object,
// we delay creation of the new object until the old one is created.
AsyncStartup bool `yaml:"-"`
</s> add // Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` </s> remove time.Sleep(1 * time.Hour)
if config.DNS.FiltersUpdateIntervalHours == 0 {
continue
</s> add if forceRefresh {
_ = refreshFiltersIfNecessary(true)
forceRefresh = false | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
<mask> //
<mask> // Algorithm:
<mask> // . Get the list of filters to be updated
<mask> // . For each filter run the download and checksum check operation
<mask> // . Stop server
<mask> // . For each filter:
<mask> // . If filter data hasn't changed, just set new update time on file
<mask> // . If filter data has changed, save it on disk
<mask> // . Apply changes to the current configuration
<mask> // . Start server
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // . If filter data has changed, save it on disk
// . Apply changes to the current configuration
// . Start server
</s> add // . If filter data has changed: rename the old file, store the new data on disk
// . Pass new filters to dnsfilter object </s> remove // Create dnsfilter asynchronously.
// Requests won't be filtered until dnsfilter is created.
// If "restart" command is received while we're creating an old dnsfilter object,
// we delay creation of the new object until the old one is created.
AsyncStartup bool `yaml:"-"`
</s> add // Filtering callback function
FilterHandler func(clientAddr string, settings *dnsfilter.RequestFilteringSettings) `yaml:"-"` </s> remove // How many times the server was started
// While creating a dnsfilter object,
// we use this value to set s.dnsFilter property only with the most recent settings.
startCounter uint32
dnsfilterCreatorChan chan dnsfilterCreatorParams
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go | |
// . If filter data has changed: rename the old file, store the new data on disk
// . Pass new filters to dnsfilter object | <mask> // . For each filter run the download and checksum check operation
<mask> // . Stop server
<mask> // . For each filter:
<mask> // . If filter data hasn't changed, just set new update time on file
<mask> // . If filter data has changed, save it on disk
<mask> // . Apply changes to the current configuration
<mask> // . Start server
<mask> func refreshFiltersIfNecessary(force bool) int {
<mask> var updateFilters []filter
<mask> var updateFlags []bool // 'true' if filter data has changed
<mask>
<mask> now := time.Now()
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // . Stop server
</s> add </s> remove // Stop DNS server:
// we close urlfilter object which in turn closes file descriptors to filter files.
// Otherwise, Windows won't allow us to remove the file which is being currently used.
_ = config.dnsServer.Stop()
</s> add </s> remove newFilters := config.Filters[:0]
</s> add newFilters := []filter{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
log.Debug("Filters: updating...")
| <mask> var updateFlags []bool // 'true' if filter data has changed
<mask>
<mask> now := time.Now()
<mask> config.RLock()
<mask> for i := range config.Filters {
<mask> f := &config.Filters[i] // otherwise we will be operating on a copy
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove // . If filter data has changed, save it on disk
// . Apply changes to the current configuration
// . Start server
</s> add // . If filter data has changed: rename the old file, store the new data on disk
// . Pass new filters to dnsfilter object </s> remove // Saving it to the filters dir now
err := uf.save()
</s> add err := uf.saveAndBackupOld() </s> remove updateCount = 0
</s> add updateCount := 0 </s> remove // . Stop server
</s> add </s> remove updateCount := 0
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
<mask> updateFilters = append(updateFilters, uf)
<mask> }
<mask> config.RUnlock()
<mask>
<mask> updateCount := 0
<mask> for i := range updateFilters {
<mask> uf := &updateFilters[i]
<mask> updated, err := uf.update()
<mask> updateFlags = append(updateFlags, updated)
<mask> if err != nil {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove updateCount = 0
</s> add updateCount := 0 </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") </s> remove // Saving it to the filters dir now
err := uf.save()
</s> add err := uf.saveAndBackupOld() </s> remove err := s.initDNSFilter(config)
if err != nil {
return err
</s> add if config != nil {
s.conf = *config
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go | |
<mask> log.Printf("Failed to update filter %s: %s\n", uf.URL, err)
<mask> continue
<mask> }
<mask> uf.LastUpdated = now
<mask> if updated {
<mask> updateCount++
<mask> }
<mask> }
<mask>
<mask> stopped := false
<mask> if updateCount != 0 {
<mask> _ = config.dnsServer.Stop()
<mask> stopped = true
<mask> }
<mask>
<mask> updateCount = 0
<mask> for i := range updateFilters {
<mask> uf := &updateFilters[i]
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove updateCount = 0
</s> add updateCount := 0 </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") </s> remove updateCount := 0
</s> add </s> remove // Saving it to the filters dir now
err := uf.save()
</s> add err := uf.saveAndBackupOld() </s> remove // Initializes the DNS filter
func (s *Server) initDNSFilter(config *ServerConfig) error {
if config != nil {
s.conf = *config
}
var filters map[int]string
filters = nil
if s.conf.FilteringEnabled {
filters = make(map[int]string)
for _, f := range s.conf.Filters {
if f.ID == 0 {
filters[int(f.ID)] = string(f.Data)
} else {
filters[int(f.ID)] = f.FilePath
}
}
}
if len(s.conf.ParentalBlockHost) == 0 {
s.conf.ParentalBlockHost = parentalBlockHost
}
if len(s.conf.SafeBrowsingBlockHost) == 0 {
s.conf.SafeBrowsingBlockHost = safeBrowsingBlockHost
}
if s.conf.AsyncStartup {
params := dnsfilterCreatorParams{
conf: s.conf.Config,
filters: filters,
}
s.startCounter++
if s.startCounter == 1 {
s.dnsfilterCreatorChan = make(chan dnsfilterCreatorParams, 1)
go s.dnsfilterCreator()
}
// remove all pending tasks
stop := false
for !stop {
select {
case <-s.dnsfilterCreatorChan:
//
default:
stop = true
}
}
s.dnsfilterCreatorChan <- params
} else {
log.Debug("creating dnsfilter...")
f := dnsfilter.New(&s.conf.Config, filters)
if f == nil {
return fmt.Errorf("could not initialize dnsfilter")
}
log.Debug("created dnsfilter")
s.dnsFilter = f
}
return nil
}
func (s *Server) dnsfilterCreator() {
for {
params := <-s.dnsfilterCreatorChan
s.Lock()
counter := s.startCounter
s.Unlock()
log.Debug("creating dnsfilter...")
f := dnsfilter.New(¶ms.conf, params.filters)
if f == nil {
log.Error("could not initialize dnsfilter")
continue
}
set := false
s.Lock()
if counter == s.startCounter {
s.dnsFilter = f
set = true
}
s.Unlock()
if set {
log.Debug("created and activated dnsfilter")
} else {
log.Debug("created dnsfilter")
}
}
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go | |
updateCount := 0 | <mask> _ = config.dnsServer.Stop()
<mask> stopped = true
<mask> }
<mask>
<mask> updateCount = 0
<mask> for i := range updateFilters {
<mask> uf := &updateFilters[i]
<mask> updated := updateFlags[i]
<mask> if updated {
<mask> // Saving it to the filters dir now
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add </s> remove // Saving it to the filters dir now
err := uf.save()
</s> add err := uf.saveAndBackupOld() </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") </s> remove updateCount := 0
</s> add </s> remove newFilters := config.Filters[:0]
</s> add newFilters := []filter{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
err := uf.saveAndBackupOld() | <mask> for i := range updateFilters {
<mask> uf := &updateFilters[i]
<mask> updated := updateFlags[i]
<mask> if updated {
<mask> // Saving it to the filters dir now
<mask> err := uf.save()
<mask> if err != nil {
<mask> log.Printf("Failed to save the updated filter %d: %s", uf.ID, err)
<mask> continue
<mask> }
<mask> } else {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove updateCount = 0
</s> add updateCount := 0 </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") </s> remove updateCount := 0
</s> add </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") | <mask> }
<mask> config.Unlock()
<mask> }
<mask>
<mask> if stopped {
<mask> err := reconfigureDNSServer()
<mask> if err != nil {
<mask> log.Error("cannot reconfigure DNS server with the new filters: %s", err)
<mask> }
<mask> }
<mask> return updateCount
<mask> }
<mask>
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove err = writeAllConfigs()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write config file: %s", err)
return
}
err = reconfigureDNSServer()
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't reconfigure the DNS server: %s", err)
return
}
</s> add onConfigModified()
enableFilters(true) </s> remove // Remove the filter file
err := os.Remove(filter.Path())
if err != nil && !os.IsNotExist(err) {
config.Unlock()
httpError(w, http.StatusInternalServerError, "Couldn't remove the filter file: %s", err)
return
</s> add err := os.Rename(filter.Path(), filter.Path()+".old")
if err != nil {
log.Error("os.Rename: %s: %s", filter.Path(), err) </s> remove if uint(r) >= uint(len(names)) {
return ""
</s> add err := d.initFiltering(filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
return err
}
return nil
}
// Starts initializing new filters by signal from channel
func (d *Dnsfilter) filtersInitializer() {
for {
params := <-d.filtersInitializerChan
err := d.initFiltering(params.filters)
if err != nil {
log.Error("Can't initialize filtering subsystem: %s", err)
continue
}
}
}
// Close - close the object
func (d *Dnsfilter) Close() {
if d != nil && d.transport != nil {
d.transport.CloseIdleConnections()
}
if d.rulesStorage != nil {
d.rulesStorage.Close() </s> remove if !config.filteringStarted {
config.filteringStarted = true
startRefreshFilters()
}
</s> add </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
log.Debug("Filters: update finished") | <mask> }
<mask> _ = os.Remove(uf.Path() + ".old")
<mask> }
<mask> }
<mask> return updateCount
<mask> }
<mask>
<mask> // Allows printable UTF-8 text with CR, LF, TAB characters
<mask> func isPrintableText(data []byte) bool {
<mask> for _, c := range data {
</s> * dnsfilter: major refactoring
* dnsfilter is controlled by package home, not dnsforward
* move HTTP handlers to dnsfilter/
* apply filtering settings without DNS server restart
* use only 1 goroutine for filters update
* apply new filters quickly (after they are ready to be used) </s> remove if stopped {
err := reconfigureDNSServer()
if err != nil {
log.Error("cannot reconfigure DNS server with the new filters: %s", err)
</s> add if updateCount != 0 {
enableFilters(false)
for i := range updateFilters {
uf := &updateFilters[i]
updated := updateFlags[i]
if !updated {
continue
}
_ = os.Remove(uf.Path() + ".old") </s> remove if updated {
updateCount++
}
}
stopped := false
if updateCount != 0 {
_ = config.dnsServer.Stop()
stopped = true
</s> add </s> remove updateCount = 0
</s> add updateCount := 0 </s> remove names := []string{
"NotFilteredNotFound",
"NotFilteredWhiteList",
"NotFilteredError",
</s> add if uint(r) >= uint(len(reasonNames)) {
return ""
}
return reasonNames[r]
}
// GetConfig - get configuration
func (d *Dnsfilter) GetConfig() RequestFilteringSettings {
c := RequestFilteringSettings{}
// d.confLock.RLock()
c.SafeSearchEnabled = d.Config.SafeSearchEnabled
c.SafeBrowsingEnabled = d.Config.SafeBrowsingEnabled
c.ParentalEnabled = d.Config.ParentalEnabled
// d.confLock.RUnlock()
return c
}
// WriteDiskConfig - write configuration
func (d *Dnsfilter) WriteDiskConfig(c *Config) {
*c = d.Config
} </s> remove newFilters := config.Filters[:0]
</s> add newFilters := []filter{} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/a59e346d4af2a1ac91ea087a0c465e9a1e593f86 | home/filter.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.