docstring_tokens
stringlengths 0
76.5k
| code_tokens
stringlengths 75
1.81M
| label_window
sequencelengths 4
2.12k
| html_url
stringlengths 74
116
| file_name
stringlengths 3
311
|
|---|---|---|---|---|
return ensure(http.MethodPost, handler) | <mask> }
<mask> }
<mask>
<mask> func ensurePOST(handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
<mask> return ensure("POST", handler)
<mask> }
<mask>
<mask> func ensureGET(handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
<mask> return ensure("GET", handler)
<mask> }
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove return ensure("GET", handler)
</s> add return ensure(http.MethodGet, handler) </s> remove func handleStatus(w http.ResponseWriter, r *http.Request) {
</s> add func handleStatus(w http.ResponseWriter, _ *http.Request) { </s> remove Context.mux.Handle("/control/login", postInstallHandler(ensureHandler("POST", handleLogin)))
httpRegister("GET", "/control/logout", handleLogout)
</s> add Context.mux.Handle("/control/login", postInstallHandler(ensureHandler(http.MethodPost, handleLogin)))
httpRegister(http.MethodGet, "/control/logout", handleLogout) </s> remove if method == "POST" || method == "PUT" || method == "DELETE" {
</s> add if method == http.MethodPost || method == http.MethodPut || method == http.MethodDelete { </s> remove s.conf.HTTPRegister("GET", "/control/dns_info", s.handleGetConfig)
s.conf.HTTPRegister("POST", "/control/dns_config", s.handleSetConfig)
s.conf.HTTPRegister("POST", "/control/test_upstream_dns", s.handleTestUpstreamDNS)
</s> add s.conf.HTTPRegister(http.MethodGet, "/control/dns_info", s.handleGetConfig)
s.conf.HTTPRegister(http.MethodPost, "/control/dns_config", s.handleSetConfig)
s.conf.HTTPRegister(http.MethodPost, "/control/test_upstream_dns", s.handleTestUpstreamDNS) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | internal/home/control.go |
return ensure(http.MethodGet, handler) | <mask> return ensure("POST", handler)
<mask> }
<mask>
<mask> func ensureGET(handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
<mask> return ensure("GET", handler)
<mask> }
<mask>
<mask> // Bridge between http.Handler object and Go function
<mask> type httpHandler struct {
<mask> handler func(http.ResponseWriter, *http.Request)
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove return ensure("POST", handler)
</s> add return ensure(http.MethodPost, handler) </s> remove func handleStatus(w http.ResponseWriter, r *http.Request) {
</s> add func handleStatus(w http.ResponseWriter, _ *http.Request) { </s> remove Context.mux.Handle("/control/login", postInstallHandler(ensureHandler("POST", handleLogin)))
httpRegister("GET", "/control/logout", handleLogout)
</s> add Context.mux.Handle("/control/login", postInstallHandler(ensureHandler(http.MethodPost, handleLogin)))
httpRegister(http.MethodGet, "/control/logout", handleLogout) </s> remove if method == "POST" || method == "PUT" || method == "DELETE" {
</s> add if method == http.MethodPost || method == http.MethodPut || method == http.MethodDelete { </s> remove s.conf.HTTPRegister("GET", "/control/dns_info", s.handleGetConfig)
s.conf.HTTPRegister("POST", "/control/dns_config", s.handleSetConfig)
s.conf.HTTPRegister("POST", "/control/test_upstream_dns", s.handleTestUpstreamDNS)
</s> add s.conf.HTTPRegister(http.MethodGet, "/control/dns_info", s.handleGetConfig)
s.conf.HTTPRegister(http.MethodPost, "/control/dns_config", s.handleSetConfig)
s.conf.HTTPRegister(http.MethodPost, "/control/test_upstream_dns", s.handleTestUpstreamDNS) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | internal/home/control.go |
'properties': | <mask> 'content':
<mask> 'application/json':
<mask> 'schema':
<mask> 'type': 'object'
<mask> 'parameters':
<mask> 'enabled':
<mask> 'type': 'boolean'
<mask> 'examples':
<mask> 'response':
<mask> 'value':
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove 'parameters':
</s> add 'properties': </s> remove 'parameters':
</s> add 'properties': </s> remove 'querylog_enabled':
'type': 'boolean'
</s> add </s> remove 'example': ''
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
'properties': | <mask> 'content':
<mask> 'application/json':
<mask> 'schema':
<mask> 'type': 'object'
<mask> 'parameters':
<mask> 'enable':
<mask> 'type': 'boolean'
<mask> 'sensitivity':
<mask> 'type': 'integer'
<mask> 'examples':
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove 'parameters':
</s> add 'properties': </s> remove 'parameters':
</s> add 'properties': </s> remove 'querylog_enabled':
'type': 'boolean'
</s> add </s> remove 'dns_address':
'type': 'string'
'example': '127.0.0.1'
</s> add 'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
'properties': | <mask> 'content':
<mask> 'application/json':
<mask> 'schema':
<mask> 'type': 'object'
<mask> 'parameters':
<mask> 'enabled':
<mask> 'type': 'boolean'
<mask> 'examples':
<mask> 'response':
<mask> 'value':
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
- 'dns_addresses' | <mask> 'ServerStatus':
<mask> 'type': 'object'
<mask> 'description': 'AdGuard Home server status and configuration'
<mask> 'required':
<mask> - 'dns_address'
<mask> - 'dns_port'
<mask> - 'protection_enabled'
<mask> - 'querylog_enabled'
<mask> - 'running'
<mask> - 'bootstrap_dns'
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove - 'querylog_enabled'
</s> add </s> remove - 'bootstrap_dns'
- 'upstream_dns'
</s> add </s> remove 'dns_address':
'type': 'string'
'example': '127.0.0.1'
</s> add 'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' </s> remove 'example': ''
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
- 'http_port' | <mask> - 'dns_addresses'
<mask> - 'dns_port'
<mask> - 'protection_enabled'
<mask> - 'running'
<mask> - 'version'
<mask> - 'language'
<mask> 'properties':
<mask> 'dns_addresses':
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove - 'bootstrap_dns'
- 'upstream_dns'
</s> add </s> remove - 'querylog_enabled'
</s> add </s> remove - 'dns_address'
</s> add - 'dns_addresses' </s> remove 'dns_address':
'type': 'string'
'example': '127.0.0.1'
</s> add 'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' </s> remove r.Method = "GET"
</s> add r.Method = http.MethodGet | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
<mask> 'required':
<mask> - 'dns_address'
<mask> - 'dns_port'
<mask> - 'protection_enabled'
<mask> - 'querylog_enabled'
<mask> - 'running'
<mask> - 'bootstrap_dns'
<mask> - 'upstream_dns'
<mask> - 'version'
<mask> - 'language'
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove - 'bootstrap_dns'
- 'upstream_dns'
</s> add </s> remove - 'dns_address'
</s> add - 'dns_addresses' </s> remove 'dns_address':
'type': 'string'
'example': '127.0.0.1'
</s> add 'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' </s> remove r.Method = "GET"
</s> add r.Method = http.MethodGet | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
|
<mask> - 'dns_port'
<mask> - 'protection_enabled'
<mask> - 'querylog_enabled'
<mask> - 'running'
<mask> - 'bootstrap_dns'
<mask> - 'upstream_dns'
<mask> - 'version'
<mask> - 'language'
<mask> 'properties':
<mask> 'dns_address':
<mask> 'type': 'string'
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove - 'querylog_enabled'
</s> add </s> remove - 'dns_address'
</s> add - 'dns_addresses' </s> remove 'dns_address':
'type': 'string'
'example': '127.0.0.1'
</s> add 'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' </s> remove r.Method = "GET"
</s> add r.Method = http.MethodGet | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
|
'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' | <mask> - 'upstream_dns'
<mask> - 'version'
<mask> - 'language'
<mask> 'properties':
<mask> 'dns_address':
<mask> 'type': 'string'
<mask> 'example': '127.0.0.1'
<mask> 'dns_port':
<mask> 'type': 'integer'
<mask> 'format': 'uint16'
<mask> 'example': 53
<mask> 'minimum': 1
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove - 'bootstrap_dns'
- 'upstream_dns'
</s> add </s> remove - 'querylog_enabled'
</s> add </s> remove 'example': ''
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
'http_port':
'type': 'integer'
'format': 'uint16'
'example': 80
'minimum': 1
'maximum': 65535 | <mask> 'example': 53
<mask> 'minimum': 1
<mask> 'maximum': 65535
<mask> 'protection_enabled':
<mask> 'type': 'boolean'
<mask> 'dhcp_available':
<mask> 'type': 'boolean'
<mask> 'running':
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove 'querylog_enabled':
'type': 'boolean'
</s> add </s> remove 'dns_address':
'type': 'string'
'example': '127.0.0.1'
</s> add 'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' </s> remove 'example': ''
</s> add </s> remove 'parameters':
</s> add 'properties': </s> remove 'parameters':
</s> add 'properties': | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
<mask> 'protection_enabled':
<mask> 'type': 'boolean'
<mask> 'dhcp_available':
<mask> 'type': 'boolean'
<mask> 'querylog_enabled':
<mask> 'type': 'boolean'
<mask> 'running':
<mask> 'type': 'boolean'
<mask> 'version':
<mask> 'type': 'string'
<mask> 'example': '0.1'
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove 'example': ''
</s> add </s> remove 'parameters':
</s> add 'properties': </s> remove 'parameters':
</s> add 'properties': </s> remove 'parameters':
</s> add 'properties': | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
|
<mask> 'properties':
<mask> 'status':
<mask> 'type': 'string'
<mask> 'default': ''
<mask> 'example': ''
<mask> 'can_autofix':
<mask> 'type': 'boolean'
<mask> 'example': false
<mask> 'CheckConfigStaticIpInfoStatic':
<mask> 'type': 'string'
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove 'example': ''
</s> add </s> remove 'dns_address':
'type': 'string'
'example': '127.0.0.1'
</s> add 'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' </s> remove 'querylog_enabled':
'type': 'boolean'
</s> add </s> remove - 'bootstrap_dns'
- 'upstream_dns'
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
|
<mask> 'description': 'Current dynamic IP address. Set if static=no'
<mask> 'error':
<mask> 'type': 'string'
<mask> 'default': ''
<mask> 'example': ''
<mask> 'description': 'Error text. Set if static=error'
<mask> 'InitialConfigurationBeta':
<mask> 'type': 'object'
<mask> 'description': >
<mask> AdGuard Home initial configuration for the first-install wizard.
</s> Pull request: all: imp http handlers, imp docs
Merge in DNS/adguard-home from fix-openapi to master
Squashed commit of the following:
commit 0e7530472fb566e5cab73d178c8ec16e5ef11dcb
Author: Ainar Garipov <[email protected]>
Date: Wed Jan 13 17:02:06 2021 +0300
all: imp http handlers, imp docs </s> remove 'example': ''
</s> add </s> remove - 'dns_address'
</s> add - 'dns_addresses' </s> remove if method == "POST" || method == "PUT" || method == "DELETE" {
</s> add if method == http.MethodPost || method == http.MethodPut || method == http.MethodDelete { </s> remove 'dns_address':
'type': 'string'
'example': '127.0.0.1'
</s> add 'dns_addresses':
'example': ['127.0.0.1']
'items':
'type': 'string'
'type': 'array' </s> remove func handleStatus(w http.ResponseWriter, r *http.Request) {
</s> add func handleStatus(w http.ResponseWriter, _ *http.Request) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4474e9fcf9073af593df76b4844f4091c1c7946e | openapi/openapi.yaml |
|
BootstrapDNS string `yaml:"bootstrap_dns"` | <mask> QueryLogEnabled bool `yaml:"querylog_enabled"`
<mask> Pprof string `yaml:"-"`
<mask> Cache string `yaml:"-"`
<mask> Prometheus string `yaml:"-"`
<mask> UpstreamDNS []string `yaml:"upstream_dns"`
<mask> }
<mask>
<mask> type filter struct {
<mask> ID int64 `json:"id" yaml:"id"` // auto-assigned when filter is added (see NextFilterId)
<mask> URL string `json:"url"`
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove return prefix + host, nil
}
</s> add </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove hosts, err := sanitiseDNSServers(string(body))
if err != nil {
httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
return
}
</s> add hosts := strings.Fields(string(body))
</s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | config.go |
BootstrapDNS: "8.8.8.8:53", | <mask> BlockedResponseTTL: 10, // in seconds
<mask> QueryLogEnabled: true,
<mask> UpstreamDNS: defaultDNS,
<mask> Cache: "cache",
<mask> Prometheus: "prometheus :9153",
<mask> },
<mask> Filters: []filter{
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove if resp.Response || resp.Opcode == dns.OpcodeQuery {
</s> add if resp.Rcode != dns.RcodeServerFailure { </s> remove hosts, err := sanitiseDNSServers(string(body))
if err != nil {
httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
return
}
</s> add hosts := strings.Fields(string(body))
</s> remove return prefix + host, nil
}
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | config.go |
{{if .UpstreamDNS}}upstream {{range .UpstreamDNS}}{{.}} {{end}} { bootstrap {{.BootstrapDNS}} }{{end}} | <mask> {{.Pprof}}
<mask> hosts {
<mask> fallthrough
<mask> }
<mask> {{if .UpstreamDNS}}upstream {{range .UpstreamDNS}}{{.}} {{end}} { bootstrap 8.8.8.8:53 }{{end}}
<mask> {{.Cache}}
<mask> {{.Prometheus}}
<mask> }
<mask> `
<mask>
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove hosts, err := sanitiseDNSServers(string(body))
if err != nil {
httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
return
}
</s> add hosts := strings.Fields(string(body))
</s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil </s> remove return prefix + host, nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | config.go |
<mask> "encoding/json"
<mask> "fmt"
<mask> "io/ioutil"
<mask> "log"
<mask> "net"
<mask> "net/http"
<mask> "os"
<mask> "path/filepath"
<mask> "regexp"
<mask> "strconv"
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove if resp.Response || resp.Opcode == dns.OpcodeQuery {
</s> add if resp.Rcode != dns.RcodeServerFailure { </s> remove {{if .UpstreamDNS}}upstream {{range .UpstreamDNS}}{{.}} {{end}} { bootstrap 8.8.8.8:53 }{{end}}
</s> add {{if .UpstreamDNS}}upstream {{range .UpstreamDNS}}{{.}} {{end}} { bootstrap {{.BootstrapDNS}} }{{end}} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
|
"github.com/AdguardTeam/AdGuardHome/upstream"
| <mask> "strconv"
<mask> "strings"
<mask> "time"
<mask>
<mask> corednsplugin "github.com/AdguardTeam/AdGuardHome/coredns_plugin"
<mask> "gopkg.in/asaskevich/govalidator.v4"
<mask> )
<mask>
<mask> const updatePeriod = time.Minute * 30
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove "github.com/miekg/dns"
</s> add </s> remove "net"
</s> add </s> remove req := dns.Msg{}
req.Id = dns.Id()
req.RecursionDesired = true
req.Question = []dns.Question{
{Name: "google-public-dns-a.google.com.", Qtype: dns.TypeA, Qclass: dns.ClassINET},
}
prefix, host := splitDNSServerPrefixServer(input)
</s> add alive, err := upstream.IsAlive(u) </s> remove hosts, err := sanitiseDNSServers(string(body))
if err != nil {
httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
return
}
</s> add hosts := strings.Fields(string(body))
| [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
<mask> "strings"
<mask> "time"
<mask>
<mask> corednsplugin "github.com/AdguardTeam/AdGuardHome/coredns_plugin"
<mask> "github.com/miekg/dns"
<mask> "gopkg.in/asaskevich/govalidator.v4"
<mask> )
<mask>
<mask> const updatePeriod = time.Minute * 30
<mask>
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove req := dns.Msg{}
req.Id = dns.Id()
req.RecursionDesired = true
req.Question = []dns.Question{
{Name: "google-public-dns-a.google.com.", Qtype: dns.TypeA, Qclass: dns.ClassINET},
}
prefix, host := splitDNSServerPrefixServer(input)
</s> add alive, err := upstream.IsAlive(u) </s> remove hosts, err := sanitiseDNSServers(string(body))
if err != nil {
httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
return
}
</s> add hosts := strings.Fields(string(body))
</s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
|
"bootstrap_dns": config.CoreDNS.BootstrapDNS, | <mask> "dns_port": config.CoreDNS.Port,
<mask> "protection_enabled": config.CoreDNS.ProtectionEnabled,
<mask> "querylog_enabled": config.CoreDNS.QueryLogEnabled,
<mask> "running": isRunning(),
<mask> "upstream_dns": config.CoreDNS.UpstreamDNS,
<mask> "version": VersionString,
<mask> }
<mask>
<mask> jsonVal, err := json.Marshal(data)
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove input, err := sanitizeDNSServer(input)
</s> add u, err := upstream.NewUpstream(input, config.CoreDNS.BootstrapDNS)
</s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove return prefix + host, nil
}
</s> add </s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
hosts := strings.Fields(string(body))
| <mask> http.Error(w, errorText, http.StatusBadRequest)
<mask> return
<mask> }
<mask> // if empty body -- user is asking for default servers
<mask> hosts, err := sanitiseDNSServers(string(body))
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
<mask> return
<mask> }
<mask> if len(hosts) == 0 {
<mask> config.CoreDNS.UpstreamDNS = defaultDNS
<mask> } else {
<mask> config.CoreDNS.UpstreamDNS = hosts
<mask> }
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add </s> remove c := dns.Client{
Timeout: time.Minute,
}
switch prefix {
case "tls://":
c.Net = "tcp-tls"
}
resp, rtt, err := c.Exchange(&req, host)
</s> add </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove return prefix + host, nil
}
</s> add </s> remove if resp.Response || resp.Opcode == dns.OpcodeQuery {
</s> add if resp.Rcode != dns.RcodeServerFailure { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
u, err := upstream.NewUpstream(input, config.CoreDNS.BootstrapDNS)
| <mask> }
<mask> }
<mask>
<mask> func checkDNS(input string) error {
<mask> input, err := sanitizeDNSServer(input)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> req := dns.Msg{}
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add </s> remove req := dns.Msg{}
req.Id = dns.Id()
req.RecursionDesired = true
req.Question = []dns.Question{
{Name: "google-public-dns-a.google.com.", Qtype: dns.TypeA, Qclass: dns.ClassINET},
}
prefix, host := splitDNSServerPrefixServer(input)
</s> add alive, err := upstream.IsAlive(u) </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove c := dns.Client{
Timeout: time.Minute,
}
switch prefix {
case "tls://":
c.Net = "tcp-tls"
}
resp, rtt, err := c.Exchange(&req, host)
</s> add </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
alive, err := upstream.IsAlive(u) | <mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> req := dns.Msg{}
<mask> req.Id = dns.Id()
<mask> req.RecursionDesired = true
<mask> req.Question = []dns.Question{
<mask> {Name: "google-public-dns-a.google.com.", Qtype: dns.TypeA, Qclass: dns.ClassINET},
<mask> }
<mask>
<mask> prefix, host := splitDNSServerPrefixServer(input)
<mask>
<mask> c := dns.Client{
<mask> Timeout: time.Minute,
<mask> }
<mask> switch prefix {
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove c := dns.Client{
Timeout: time.Minute,
}
switch prefix {
case "tls://":
c.Net = "tcp-tls"
}
resp, rtt, err := c.Exchange(&req, host)
</s> add </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove input, err := sanitizeDNSServer(input)
</s> add u, err := upstream.NewUpstream(input, config.CoreDNS.BootstrapDNS)
</s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
<mask> }
<mask>
<mask> prefix, host := splitDNSServerPrefixServer(input)
<mask>
<mask> c := dns.Client{
<mask> Timeout: time.Minute,
<mask> }
<mask> switch prefix {
<mask> case "tls://":
<mask> c.Net = "tcp-tls"
<mask> }
<mask>
<mask> resp, rtt, err := c.Exchange(&req, host)
<mask> if err != nil {
<mask> return fmt.Errorf("couldn't communicate with DNS server %s: %s", input, err)
<mask> }
<mask> trace("exchange with %s took %v", input, rtt)
<mask> if len(resp.Answer) != 1 {
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add </s> remove req := dns.Msg{}
req.Id = dns.Id()
req.RecursionDesired = true
req.Question = []dns.Question{
{Name: "google-public-dns-a.google.com.", Qtype: dns.TypeA, Qclass: dns.ClassINET},
}
prefix, host := splitDNSServerPrefixServer(input)
</s> add alive, err := upstream.IsAlive(u) </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove return prefix + host, nil
}
</s> add </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
|
<mask> resp, rtt, err := c.Exchange(&req, host)
<mask> if err != nil {
<mask> return fmt.Errorf("couldn't communicate with DNS server %s: %s", input, err)
<mask> }
<mask> trace("exchange with %s took %v", input, rtt)
<mask> if len(resp.Answer) != 1 {
<mask> return fmt.Errorf("DNS server %s returned wrong answer", input)
<mask> }
<mask> if t, ok := resp.Answer[0].(*dns.A); ok {
<mask> if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
<mask> return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
<mask> }
<mask> }
<mask>
<mask> return nil
<mask> }
<mask>
<mask> func sanitiseDNSServers(input string) ([]string, error) {
<mask> fields := strings.Fields(input)
<mask> hosts := make([]string, 0)
<mask> for _, field := range fields {
<mask> sanitized, err := sanitizeDNSServer(field)
<mask> if err != nil {
<mask> return hosts, err
<mask> }
<mask> hosts = append(hosts, sanitized)
<mask> }
<mask> return hosts, nil
<mask> }
<mask>
<mask> func getDNSServerPrefix(input string) string {
<mask> prefix := ""
<mask> switch {
<mask> case strings.HasPrefix(input, "dns://"):
<mask> prefix = "dns://"
<mask> case strings.HasPrefix(input, "tls://"):
<mask> prefix = "tls://"
<mask> }
<mask> return prefix
<mask> }
<mask>
<mask> func splitDNSServerPrefixServer(input string) (string, string) {
<mask> prefix := getDNSServerPrefix(input)
<mask> host := strings.TrimPrefix(input, prefix)
<mask> return prefix, host
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove c := dns.Client{
Timeout: time.Minute,
}
switch prefix {
case "tls://":
c.Net = "tcp-tls"
}
resp, rtt, err := c.Exchange(&req, host)
</s> add </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove return prefix + host, nil
}
</s> add </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil </s> remove input, err := sanitizeDNSServer(input)
</s> add u, err := upstream.NewUpstream(input, config.CoreDNS.BootstrapDNS)
| [
"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",
"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/451922b858c77145342bc568f7773433d281fee6 | control.go |
|
if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) | <mask> }
<mask> return prefix
<mask> }
<mask>
<mask> func splitDNSServerPrefixServer(input string) (string, string) {
<mask> prefix := getDNSServerPrefix(input)
<mask> host := strings.TrimPrefix(input, prefix)
<mask> return prefix, host
<mask> }
<mask>
<mask> func sanitizeDNSServer(input string) (string, error) {
<mask> prefix, host := splitDNSServerPrefixServer(input)
<mask> host = appendPortIfMissing(prefix, host)
<mask> {
<mask> h, _, err := net.SplitHostPort(host)
<mask> if err != nil {
<mask> return "", err
<mask> }
<mask> ip := net.ParseIP(h)
<mask> if ip == nil {
<mask> return "", fmt.Errorf("invalid DNS server field: %s", h)
<mask> }
<mask> }
<mask> return prefix + host, nil
<mask> }
<mask>
<mask> func appendPortIfMissing(prefix, input string) string {
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove return prefix + host, nil
}
</s> add </s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil </s> remove c := dns.Client{
Timeout: time.Minute,
}
switch prefix {
case "tls://":
c.Net = "tcp-tls"
}
resp, rtt, err := c.Exchange(&req, host)
</s> add </s> remove req := dns.Msg{}
req.Id = dns.Id()
req.RecursionDesired = true
req.Question = []dns.Question{
{Name: "google-public-dns-a.google.com.", Qtype: dns.TypeA, Qclass: dns.ClassINET},
}
prefix, host := splitDNSServerPrefixServer(input)
</s> add alive, err := upstream.IsAlive(u) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"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/451922b858c77145342bc568f7773433d281fee6 | control.go |
<mask> if ip == nil {
<mask> return "", fmt.Errorf("invalid DNS server field: %s", h)
<mask> }
<mask> }
<mask> return prefix + host, nil
<mask> }
<mask>
<mask> func appendPortIfMissing(prefix, input string) string {
<mask> port := "53"
<mask> switch prefix {
<mask> case "tls://":
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil </s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add </s> remove c := dns.Client{
Timeout: time.Minute,
}
switch prefix {
case "tls://":
c.Net = "tcp-tls"
}
resp, rtt, err := c.Exchange(&req, host)
</s> add </s> remove input, err := sanitizeDNSServer(input)
</s> add u, err := upstream.NewUpstream(input, config.CoreDNS.BootstrapDNS)
| [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | control.go |
|
return nil | <mask> }
<mask> return prefix + host, nil
<mask> }
<mask>
<mask> func appendPortIfMissing(prefix, input string) string {
<mask> port := "53"
<mask> switch prefix {
<mask> case "tls://":
<mask> port = "853"
<mask> }
<mask> _, _, err := net.SplitHostPort(input)
<mask> if err == nil {
<mask> return input
<mask> }
<mask> return net.JoinHostPort(input, port)
<mask> }
<mask>
<mask> //noinspection GoUnusedParameter
<mask> func handleGetVersionJSON(w http.ResponseWriter, r *http.Request) {
<mask> now := time.Now()
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove return prefix + host, nil
}
</s> add </s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add </s> remove c := dns.Client{
Timeout: time.Minute,
}
switch prefix {
case "tls://":
c.Net = "tcp-tls"
}
resp, rtt, err := c.Exchange(&req, host)
</s> add </s> remove input, err := sanitizeDNSServer(input)
</s> add u, err := upstream.NewUpstream(input, config.CoreDNS.BootstrapDNS)
| [
"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/451922b858c77145342bc568f7773433d281fee6 | control.go |
bootstrap_dns: 8.8.8.8:53 | <mask> dns_port: 53
<mask> protection_enabled: true
<mask> querylog_enabled: true
<mask> running: true
<mask> upstream_dns:
<mask> - 1.1.1.1
<mask> - 1.0.0.1
<mask> version: "v0.1"
<mask> /enable_protection:
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove req := dns.Msg{}
req.Id = dns.Id()
req.RecursionDesired = true
req.Question = []dns.Question{
{Name: "google-public-dns-a.google.com.", Qtype: dns.TypeA, Qclass: dns.ClassINET},
}
prefix, host := splitDNSServerPrefixServer(input)
</s> add alive, err := upstream.IsAlive(u) </s> remove hosts, err := sanitiseDNSServers(string(body))
if err != nil {
httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
return
}
</s> add hosts := strings.Fields(string(body))
</s> remove {{if .UpstreamDNS}}upstream {{range .UpstreamDNS}}{{.}} {{end}} { bootstrap 8.8.8.8:53 }{{end}}
</s> add {{if .UpstreamDNS}}upstream {{range .UpstreamDNS}}{{.}} {{end}} { bootstrap {{.BootstrapDNS}} }{{end}} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | openapi.yaml |
if resp.Rcode != dns.RcodeServerFailure { | <mask>
<mask> // If we got a header, we're alright, basically only care about I/O errors 'n stuff.
<mask> if err != nil && resp != nil {
<mask> // Silly check, something sane came back.
<mask> if resp.Response || resp.Opcode == dns.OpcodeQuery {
<mask> err = nil
<mask> }
<mask> }
<mask>
<mask> return err == nil, err
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove hosts, err := sanitiseDNSServers(string(body))
if err != nil {
httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
return
}
</s> add hosts := strings.Fields(string(body))
</s> remove func splitDNSServerPrefixServer(input string) (string, string) {
prefix := getDNSServerPrefix(input)
host := strings.TrimPrefix(input, prefix)
return prefix, host
}
func sanitizeDNSServer(input string) (string, error) {
prefix, host := splitDNSServerPrefixServer(input)
host = appendPortIfMissing(prefix, host)
{
h, _, err := net.SplitHostPort(host)
if err != nil {
return "", err
}
ip := net.ParseIP(h)
if ip == nil {
return "", fmt.Errorf("invalid DNS server field: %s", h)
}
</s> add if !alive {
return fmt.Errorf("DNS server has not passed the healthcheck: %s", input) </s> remove func appendPortIfMissing(prefix, input string) string {
port := "53"
switch prefix {
case "tls://":
port = "853"
}
_, _, err := net.SplitHostPort(input)
if err == nil {
return input
}
return net.JoinHostPort(input, port)
</s> add return nil </s> remove return prefix + host, nil
}
</s> add </s> remove c := dns.Client{
Timeout: time.Minute,
}
switch prefix {
case "tls://":
c.Net = "tcp-tls"
}
resp, rtt, err := c.Exchange(&req, host)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | upstream/helpers.go |
// Persistent connections cache -- almost similar to the same used in the CoreDNS forward plugin
| <mask> )
<mask>
<mask> const (
<mask> defaultExpire = 10 * time.Second
<mask> minDialTimeout = 100 * time.Millisecond
<mask> maxDialTimeout = 30 * time.Second
</s> Added bootstrap DNS to the config file
DNS healthcheck now uses the upstream package methods </s> remove "github.com/miekg/dns"
</s> add </s> remove req := dns.Msg{}
req.Id = dns.Id()
req.RecursionDesired = true
req.Question = []dns.Question{
{Name: "google-public-dns-a.google.com.", Qtype: dns.TypeA, Qclass: dns.ClassINET},
}
prefix, host := splitDNSServerPrefixServer(input)
</s> add alive, err := upstream.IsAlive(u) </s> remove hosts, err := sanitiseDNSServers(string(body))
if err != nil {
httpError(w, http.StatusBadRequest, "Invalid DNS servers were given: %s", err)
return
}
</s> add hosts := strings.Fields(string(body))
</s> remove trace("exchange with %s took %v", input, rtt)
if len(resp.Answer) != 1 {
return fmt.Errorf("DNS server %s returned wrong answer", input)
}
if t, ok := resp.Answer[0].(*dns.A); ok {
if !net.IPv4(8, 8, 8, 8).Equal(t.A) {
return fmt.Errorf("DNS server %s returned wrong answer: %v", input, t.A)
}
}
return nil
}
func sanitiseDNSServers(input string) ([]string, error) {
fields := strings.Fields(input)
hosts := make([]string, 0)
for _, field := range fields {
sanitized, err := sanitizeDNSServer(field)
if err != nil {
return hosts, err
}
hosts = append(hosts, sanitized)
}
return hosts, nil
}
func getDNSServerPrefix(input string) string {
prefix := ""
switch {
case strings.HasPrefix(input, "dns://"):
prefix = "dns://"
case strings.HasPrefix(input, "tls://"):
prefix = "tls://"
}
return prefix
}
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/451922b858c77145342bc568f7773433d281fee6 | upstream/persistent.go |
<mask> }
<mask> }
<mask>
<mask> func handleBlockedServicesList(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> config.RLock()
<mask> list := config.DNS.BlockedServices
<mask> config.RUnlock()
<mask>
<mask> w.Header().Set("Content-Type", "application/json")
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/blocked_services.go |
|
<mask> }
<mask> }
<mask>
<mask> func handleBlockedServicesSet(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> list := []string{}
<mask> err := json.NewDecoder(r.Body).Decode(&list)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "json.Decode: %s", err)
<mask> return
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/blocked_services.go |
|
httpRegister(http.MethodGet, "/control/blocked_services/list", handleBlockedServicesList)
httpRegister(http.MethodPost, "/control/blocked_services/set", handleBlockedServicesSet) | <mask> }
<mask>
<mask> // RegisterBlockedServicesHandlers - register HTTP handlers
<mask> func RegisterBlockedServicesHandlers() {
<mask> http.HandleFunc("/control/blocked_services/list", postInstall(optionalAuth(ensureGET(handleBlockedServicesList))))
<mask> http.HandleFunc("/control/blocked_services/set", postInstall(optionalAuth(ensurePOST(handleBlockedServicesSet))))
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove http.HandleFunc("/control/clients", postInstall(optionalAuth(ensureGET(handleGetClients))))
http.HandleFunc("/control/clients/add", postInstall(optionalAuth(ensurePOST(handleAddClient))))
http.HandleFunc("/control/clients/delete", postInstall(optionalAuth(ensurePOST(handleDelClient))))
http.HandleFunc("/control/clients/update", postInstall(optionalAuth(ensurePOST(handleUpdateClient))))
</s> add httpRegister(http.MethodGet, "/control/clients", handleGetClients)
httpRegister(http.MethodPost, "/control/clients/add", handleAddClient)
httpRegister(http.MethodPost, "/control/clients/delete", handleDelClient)
httpRegister(http.MethodPost, "/control/clients/update", handleUpdateClient) </s> remove http.HandleFunc("/control/tls/status", postInstall(optionalAuth(ensureGET(handleTLSStatus))))
http.HandleFunc("/control/tls/configure", postInstall(optionalAuth(ensurePOST(handleTLSConfigure))))
http.HandleFunc("/control/tls/validate", postInstall(optionalAuth(ensurePOST(handleTLSValidate))))
</s> add httpRegister(http.MethodGet, "/control/tls/status", handleTLSStatus)
httpRegister(http.MethodPost, "/control/tls/configure", handleTLSConfigure)
httpRegister(http.MethodPost, "/control/tls/validate", handleTLSValidate) </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/blocked_services.go |
<mask> }
<mask>
<mask> // respond with information about configured clients
<mask> func handleGetClients(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> data := clientListJSON{}
<mask>
<mask> config.clients.lock.Lock()
<mask> for _, c := range config.clients.list {
<mask> cj := clientJSON{
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/clients.go |
|
<mask> }
<mask>
<mask> // Add a new client
<mask> func handleAddClient(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> body, err := ioutil.ReadAll(r.Body)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "failed to read request body: %s", err)
<mask> return
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/clients.go |
|
<mask> }
<mask>
<mask> // Remove client
<mask> func handleDelClient(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> body, err := ioutil.ReadAll(r.Body)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "failed to read request body: %s", err)
<mask> return
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/clients.go |
|
<mask> }
<mask>
<mask> // Update client's properties
<mask> func handleUpdateClient(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> body, err := ioutil.ReadAll(r.Body)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "failed to read request body: %s", err)
<mask> return
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/clients.go |
|
httpRegister(http.MethodGet, "/control/clients", handleGetClients)
httpRegister(http.MethodPost, "/control/clients/add", handleAddClient)
httpRegister(http.MethodPost, "/control/clients/delete", handleDelClient)
httpRegister(http.MethodPost, "/control/clients/update", handleUpdateClient) | <mask> }
<mask>
<mask> // RegisterClientsHandlers registers HTTP handlers
<mask> func RegisterClientsHandlers() {
<mask> http.HandleFunc("/control/clients", postInstall(optionalAuth(ensureGET(handleGetClients))))
<mask> http.HandleFunc("/control/clients/add", postInstall(optionalAuth(ensurePOST(handleAddClient))))
<mask> http.HandleFunc("/control/clients/delete", postInstall(optionalAuth(ensurePOST(handleDelClient))))
<mask> http.HandleFunc("/control/clients/update", postInstall(optionalAuth(ensurePOST(handleUpdateClient))))
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove http.HandleFunc("/control/tls/status", postInstall(optionalAuth(ensureGET(handleTLSStatus))))
http.HandleFunc("/control/tls/configure", postInstall(optionalAuth(ensurePOST(handleTLSConfigure))))
http.HandleFunc("/control/tls/validate", postInstall(optionalAuth(ensurePOST(handleTLSValidate))))
</s> add httpRegister(http.MethodGet, "/control/tls/status", handleTLSStatus)
httpRegister(http.MethodPost, "/control/tls/configure", handleTLSConfigure)
httpRegister(http.MethodPost, "/control/tls/validate", handleTLSValidate) </s> remove http.HandleFunc("/control/blocked_services/list", postInstall(optionalAuth(ensureGET(handleBlockedServicesList))))
http.HandleFunc("/control/blocked_services/set", postInstall(optionalAuth(ensurePOST(handleBlockedServicesSet))))
</s> add httpRegister(http.MethodGet, "/control/blocked_services/list", handleBlockedServicesList)
httpRegister(http.MethodPost, "/control/blocked_services/set", handleBlockedServicesSet) </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/clients.go |
<mask> import (
<mask> "bytes"
<mask> "encoding/json"
<mask> "fmt"
<mask> "io/ioutil"
<mask> "net"
<mask> "net/http"
<mask> "os"
<mask> "sort"
<mask> "strconv"
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove "os"
</s> add </s> remove h.handler = ensure("GET", handler)
</s> add h.handler = ensure(method, handler) </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> "fmt"
<mask> "io/ioutil"
<mask> "net"
<mask> "net/http"
<mask> "os"
<mask> "sort"
<mask> "strconv"
<mask> "strings"
<mask> "time"
<mask>
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove "io/ioutil"
</s> add </s> remove h.handler = ensure("GET", handler)
</s> add h.handler = ensure(method, handler) </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> "github.com/AdguardTeam/golibs/log"
<mask> "github.com/AdguardTeam/golibs/utils"
<mask> "github.com/NYTimes/gziphandler"
<mask> "github.com/miekg/dns"
<mask> govalidator "gopkg.in/asaskevich/govalidator.v4"
<mask> )
<mask>
<mask> const updatePeriod = time.Hour * 24
<mask>
<mask> var protocols = []string{"tls://", "https://", "tcp://", "sdns://"}
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove h.handler = ensure("GET", handler)
</s> add h.handler = ensure(method, handler) </s> remove http.HandleFunc("/control/tls/status", postInstall(optionalAuth(ensureGET(handleTLSStatus))))
http.HandleFunc("/control/tls/configure", postInstall(optionalAuth(ensurePOST(handleTLSConfigure))))
http.HandleFunc("/control/tls/validate", postInstall(optionalAuth(ensurePOST(handleTLSValidate))))
</s> add httpRegister(http.MethodGet, "/control/tls/status", handleTLSStatus)
httpRegister(http.MethodPost, "/control/tls/configure", handleTLSConfigure)
httpRegister(http.MethodPost, "/control/tls/validate", handleTLSValidate) </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> return dnsAddresses
<mask> }
<mask>
<mask> func handleStatus(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> data := map[string]interface{}{
<mask> "dns_addresses": getDNSAddresses(),
<mask> "http_port": config.BindPort,
<mask> "dns_port": config.DNS.Port,
<mask> "protection_enabled": config.DNS.ProtectionEnabled,
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> }
<mask> }
<mask>
<mask> func handleProtectionEnable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.ProtectionEnabled = true
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleProtectionDisable(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleProtectionDisable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.ProtectionEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> // -----
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> // -----
<mask> // stats
<mask> // -----
<mask> func handleQueryLogEnable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.QueryLogEnabled = true
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleQueryLogDisable(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleQueryLogDisable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.QueryLogEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleQueryLog(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleQueryLog(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> data := config.dnsServer.GetQueryLog()
<mask>
<mask> jsonVal, err := json.Marshal(data)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Couldn't marshal data into json: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> }
<mask> }
<mask>
<mask> func handleStatsTop(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> s := config.dnsServer.GetStatsTop()
<mask>
<mask> // use manual json marshalling because we want maps to be sorted by value
<mask> statsJSON := bytes.Buffer{}
<mask> statsJSON.WriteString("{\n")
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("New app version check is disabled by user")
</s> add httpError(w, http.StatusInternalServerError, "New app version check is disabled by user") </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> }
<mask>
<mask> // handleStatsReset resets the stats caches
<mask> func handleStatsReset(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.dnsServer.PurgeStats()
<mask> _, err := fmt.Fprintf(w, "OK\n")
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove // ---------
// filtering
// ---------
func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
data := map[string]interface{}{
"enabled": config.DNS.FilteringEnabled,
}
config.RLock()
data["filters"] = config.Filters
data["user_rules"] = config.UserRules
jsonVal, err := json.Marshal(data)
config.RUnlock()
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
}
}
func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
f := filter{}
err := json.NewDecoder(r.Body).Decode(&f)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if len(f.URL) == 0 {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(f.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// Check for duplicates
if filterExists(f.URL) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
// Set necessary properties
f.ID = assignUniqueFilterID()
f.Enabled = true
// Download the filter contents
ok, err := f.update()
if err != nil {
httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
return
}
if f.RulesCount == 0 {
httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
return
}
if !ok {
httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
return
}
// Save the filter contents
err = f.save()
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
return
}
// URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
// TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
if !filterAdd(f) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
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
}
_, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
}
}
func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
type request struct {
URL string `json:"url"`
}
req := request{}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if valid := govalidator.IsRequestURL(req.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// 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()
// go through each element and delete if url matches
config.Lock()
newFilters := config.Filters[:0]
for _, filter := range config.Filters {
if filter.URL != req.URL {
newFilters = append(newFilters, filter)
} else {
// 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
}
log.Debug("os.Remove(%s)", filter.Path())
}
}
// Update the configuration after removing filter files
config.Filters = newFilters
config.Unlock()
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, true)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, false)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
return
}
config.UserRules = strings.Split(string(body), "\n")
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
}
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> }
<mask>
<mask> // handleStats returns aggregated stats data for the 24 hours
<mask> func handleStats(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> summed := config.dnsServer.GetAggregatedStats()
<mask>
<mask> statsJSON, err := json.Marshal(summed)
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Unable to marshal status json: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove // ---------
// filtering
// ---------
func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
data := map[string]interface{}{
"enabled": config.DNS.FilteringEnabled,
}
config.RLock()
data["filters"] = config.Filters
data["user_rules"] = config.UserRules
jsonVal, err := json.Marshal(data)
config.RUnlock()
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
}
}
func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
f := filter{}
err := json.NewDecoder(r.Body).Decode(&f)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if len(f.URL) == 0 {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(f.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// Check for duplicates
if filterExists(f.URL) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
// Set necessary properties
f.ID = assignUniqueFilterID()
f.Enabled = true
// Download the filter contents
ok, err := f.update()
if err != nil {
httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
return
}
if f.RulesCount == 0 {
httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
return
}
if !ok {
httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
return
}
// Save the filter contents
err = f.save()
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
return
}
// URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
// TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
if !filterAdd(f) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
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
}
_, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
}
}
func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
type request struct {
URL string `json:"url"`
}
req := request{}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if valid := govalidator.IsRequestURL(req.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// 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()
// go through each element and delete if url matches
config.Lock()
newFilters := config.Filters[:0]
for _, filter := range config.Filters {
if filter.URL != req.URL {
newFilters = append(newFilters, filter)
} else {
// 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
}
log.Debug("os.Remove(%s)", filter.Path())
}
}
// Update the configuration after removing filter files
config.Filters = newFilters
config.Unlock()
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, true)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, false)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
return
}
config.UserRules = strings.Split(string(body), "\n")
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
}
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> }
<mask>
<mask> // HandleStatsHistory returns historical stats data for the 24 hours
<mask> func handleStatsHistory(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> // handle time unit and prepare our time window size
<mask> timeUnitString := r.URL.Query().Get("time_unit")
<mask> var timeUnit time.Duration
<mask> switch timeUnitString {
<mask> case "seconds":
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> AllServers bool `json:"all_servers"` // --all-servers param for dnsproxy
<mask> }
<mask>
<mask> func handleSetUpstreamConfig(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> newconfig := upstreamConfig{}
<mask> err := json.NewDecoder(r.Body).Decode(&newconfig)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to parse new upstreams config json: %s", err)
<mask> return
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> return nil
<mask> }
<mask>
<mask> func handleTestUpstreamDNS(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> upstreamConfig := upstreamConfig{}
<mask> err := json.NewDecoder(r.Body).Decode(&upstreamConfig)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
<mask> return
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> log.Debug("DNS %s works OK", input)
<mask> return nil
<mask> }
<mask>
<mask> // ---------
<mask> // filtering
<mask> // ---------
<mask>
<mask> func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.FilteringEnabled = true
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.FilteringEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> data := map[string]interface{}{
<mask> "enabled": config.DNS.FilteringEnabled,
<mask> }
<mask>
<mask> config.RLock()
<mask> data["filters"] = config.Filters
<mask> data["user_rules"] = config.UserRules
<mask> jsonVal, err := json.Marshal(data)
<mask> config.RUnlock()
<mask>
<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> func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> f := filter{}
<mask> err := json.NewDecoder(r.Body).Decode(&f)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
<mask> return
<mask> }
<mask>
<mask> if len(f.URL) == 0 {
<mask> http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> if valid := govalidator.IsRequestURL(f.URL); !valid {
<mask> http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> // Check for duplicates
<mask> if filterExists(f.URL) {
<mask> httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
<mask> return
<mask> }
<mask>
<mask> // Set necessary properties
<mask> f.ID = assignUniqueFilterID()
<mask> f.Enabled = true
<mask>
<mask> // Download the filter contents
<mask> ok, err := f.update()
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
<mask> return
<mask> }
<mask> if f.RulesCount == 0 {
<mask> httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
<mask> return
<mask> }
<mask> if !ok {
<mask> httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
<mask> return
<mask> }
<mask>
<mask> // Save the filter contents
<mask> err = f.save()
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
<mask> return
<mask> }
<mask>
<mask> // URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
<mask> // TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
<mask> if !filterAdd(f) {
<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> }
<mask> }
<mask>
<mask> func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> type request struct {
<mask> URL string `json:"url"`
<mask> }
<mask> req := request{}
<mask> err := json.NewDecoder(r.Body).Decode(&req)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
<mask> return
<mask> }
<mask>
<mask> if valid := govalidator.IsRequestURL(req.URL); !valid {
<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 {
<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
<mask> config.Filters = newFilters
<mask> config.Unlock()
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<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> url, ok := parameters["url"]
<mask> if !ok {
<mask> http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> if valid := govalidator.IsRequestURL(url); !valid {
<mask> http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> found := filterEnable(url, true)
<mask> if !found {
<mask> http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<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> url, ok := parameters["url"]
<mask> if !ok {
<mask> http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> if valid := govalidator.IsRequestURL(url); !valid {
<mask> http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> found := filterEnable(url, false)
<mask> if !found {
<mask> http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
<mask> return
<mask> }
<mask>
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> body, err := ioutil.ReadAll(r.Body)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
<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> log.Tracef("%s %v", r.Method, r.URL)
<mask> updated := refreshFiltersIfNecessary(true)
<mask> fmt.Fprintf(w, "OK %d filters updated\n", updated)
<mask> }
<mask>
<mask> // ------------
<mask> // safebrowsing
<mask> // ------------
<mask>
<mask> func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</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",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"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/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> // safebrowsing
<mask> // ------------
<mask>
<mask> func handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.SafeBrowsingEnabled = true
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.SafeBrowsingEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> data := map[string]interface{}{
<mask> "enabled": config.DNS.SafeBrowsingEnabled,
<mask> }
<mask> jsonVal, err := json.Marshal(data)
<mask> if err != nil {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> // --------
<mask> // parental
<mask> // --------
<mask> func handleParentalEnable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<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> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove // ---------
// filtering
// ---------
func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
data := map[string]interface{}{
"enabled": config.DNS.FilteringEnabled,
}
config.RLock()
data["filters"] = config.Filters
data["user_rules"] = config.UserRules
jsonVal, err := json.Marshal(data)
config.RUnlock()
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
}
}
func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
f := filter{}
err := json.NewDecoder(r.Body).Decode(&f)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if len(f.URL) == 0 {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(f.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// Check for duplicates
if filterExists(f.URL) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
// Set necessary properties
f.ID = assignUniqueFilterID()
f.Enabled = true
// Download the filter contents
ok, err := f.update()
if err != nil {
httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
return
}
if f.RulesCount == 0 {
httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
return
}
if !ok {
httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
return
}
// Save the filter contents
err = f.save()
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
return
}
// URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
// TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
if !filterAdd(f) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
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
}
_, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
}
}
func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
type request struct {
URL string `json:"url"`
}
req := request{}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if valid := govalidator.IsRequestURL(req.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// 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()
// go through each element and delete if url matches
config.Lock()
newFilters := config.Filters[:0]
for _, filter := range config.Filters {
if filter.URL != req.URL {
newFilters = append(newFilters, filter)
} else {
// 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
}
log.Debug("os.Remove(%s)", filter.Path())
}
}
// Update the configuration after removing filter files
config.Filters = newFilters
config.Unlock()
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, true)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, false)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
return
}
config.UserRules = strings.Split(string(body), "\n")
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
}
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleParentalDisable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.ParentalEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleParentalStatus(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> data := map[string]interface{}{
<mask> "enabled": config.DNS.ParentalEnabled,
<mask> }
<mask> if config.DNS.ParentalEnabled {
<mask> data["sensitivity"] = config.DNS.ParentalSensitivity
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> // safebrowsing
<mask> // ------------
<mask>
<mask> func handleSafeSearchEnable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.SafeSearchEnabled = true
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeSearchDisable(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> config.DNS.SafeSearchEnabled = false
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleSafeSearchStatus(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> data := map[string]interface{}{
<mask> "enabled": config.DNS.SafeSearchEnabled,
<mask> }
<mask> jsonVal, err := json.Marshal(data)
<mask> if err != nil {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
<mask> // --------------
<mask> // DNS-over-HTTPS
<mask> // --------------
<mask> func handleDOH(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> if r.TLS == nil {
<mask> httpError(w, http.StatusNotFound, "Not Found")
<mask> return
<mask> }
<mask>
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
|
httpRegister(http.MethodGet, "/control/status", handleStatus)
httpRegister(http.MethodPost, "/control/enable_protection", handleProtectionEnable)
httpRegister(http.MethodPost, "/control/disable_protection", handleProtectionDisable)
httpRegister(http.MethodGet, "/control/querylog", handleQueryLog)
httpRegister(http.MethodPost, "/control/querylog_enable", handleQueryLogEnable)
httpRegister(http.MethodPost, "/control/querylog_disable", handleQueryLogDisable)
httpRegister(http.MethodPost, "/control/set_upstreams_config", handleSetUpstreamConfig)
httpRegister(http.MethodPost, "/control/test_upstream_dns", handleTestUpstreamDNS)
httpRegister(http.MethodPost, "/control/i18n/change_language", handleI18nChangeLanguage)
httpRegister(http.MethodGet, "/control/i18n/current_language", handleI18nCurrentLanguage)
httpRegister(http.MethodGet, "/control/stats_top", handleStatsTop)
httpRegister(http.MethodGet, "/control/stats", handleStats)
httpRegister(http.MethodGet, "/control/stats_history", handleStatsHistory)
httpRegister(http.MethodPost, "/control/stats_reset", handleStatsReset) | <mask> // ------------------------
<mask> // registration of handlers
<mask> // ------------------------
<mask> func registerControlHandlers() {
<mask> http.HandleFunc("/control/status", postInstall(optionalAuth(ensureGET(handleStatus))))
<mask> http.HandleFunc("/control/enable_protection", postInstall(optionalAuth(ensurePOST(handleProtectionEnable))))
<mask> http.HandleFunc("/control/disable_protection", postInstall(optionalAuth(ensurePOST(handleProtectionDisable))))
<mask> http.Handle("/control/querylog", postInstallHandler(optionalAuthHandler(gziphandler.GzipHandler(ensureGETHandler(handleQueryLog)))))
<mask> http.HandleFunc("/control/querylog_enable", postInstall(optionalAuth(ensurePOST(handleQueryLogEnable))))
<mask> http.HandleFunc("/control/querylog_disable", postInstall(optionalAuth(ensurePOST(handleQueryLogDisable))))
<mask> http.HandleFunc("/control/set_upstreams_config", postInstall(optionalAuth(ensurePOST(handleSetUpstreamConfig))))
<mask> http.HandleFunc("/control/test_upstream_dns", postInstall(optionalAuth(ensurePOST(handleTestUpstreamDNS))))
<mask> http.HandleFunc("/control/i18n/change_language", postInstall(optionalAuth(ensurePOST(handleI18nChangeLanguage))))
<mask> http.HandleFunc("/control/i18n/current_language", postInstall(optionalAuth(ensureGET(handleI18nCurrentLanguage))))
<mask> http.HandleFunc("/control/stats_top", postInstall(optionalAuth(ensureGET(handleStatsTop))))
<mask> http.HandleFunc("/control/stats", postInstall(optionalAuth(ensureGET(handleStats))))
<mask> http.HandleFunc("/control/stats_history", postInstall(optionalAuth(ensureGET(handleStatsHistory))))
<mask> http.HandleFunc("/control/stats_reset", postInstall(optionalAuth(ensurePOST(handleStatsReset))))
<mask> http.HandleFunc("/control/version.json", postInstall(optionalAuth(handleGetVersionJSON)))
<mask> http.HandleFunc("/control/update", postInstall(optionalAuth(ensurePOST(handleUpdate))))
<mask> http.HandleFunc("/control/filtering/enable", postInstall(optionalAuth(ensurePOST(handleFilteringEnable))))
<mask> http.HandleFunc("/control/filtering/disable", postInstall(optionalAuth(ensurePOST(handleFilteringDisable))))
<mask> http.HandleFunc("/control/filtering/add_url", postInstall(optionalAuth(ensurePOST(handleFilteringAddURL))))
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove http.HandleFunc("/control/update", postInstall(optionalAuth(ensurePOST(handleUpdate))))
http.HandleFunc("/control/filtering/enable", postInstall(optionalAuth(ensurePOST(handleFilteringEnable))))
http.HandleFunc("/control/filtering/disable", postInstall(optionalAuth(ensurePOST(handleFilteringDisable))))
http.HandleFunc("/control/filtering/add_url", postInstall(optionalAuth(ensurePOST(handleFilteringAddURL))))
http.HandleFunc("/control/filtering/remove_url", postInstall(optionalAuth(ensurePOST(handleFilteringRemoveURL))))
http.HandleFunc("/control/filtering/enable_url", postInstall(optionalAuth(ensurePOST(handleFilteringEnableURL))))
http.HandleFunc("/control/filtering/disable_url", postInstall(optionalAuth(ensurePOST(handleFilteringDisableURL))))
http.HandleFunc("/control/filtering/refresh", postInstall(optionalAuth(ensurePOST(handleFilteringRefresh))))
http.HandleFunc("/control/filtering/status", postInstall(optionalAuth(ensureGET(handleFilteringStatus))))
http.HandleFunc("/control/filtering/set_rules", postInstall(optionalAuth(ensurePOST(handleFilteringSetRules))))
http.HandleFunc("/control/safebrowsing/enable", postInstall(optionalAuth(ensurePOST(handleSafeBrowsingEnable))))
http.HandleFunc("/control/safebrowsing/disable", postInstall(optionalAuth(ensurePOST(handleSafeBrowsingDisable))))
http.HandleFunc("/control/safebrowsing/status", postInstall(optionalAuth(ensureGET(handleSafeBrowsingStatus))))
http.HandleFunc("/control/parental/enable", postInstall(optionalAuth(ensurePOST(handleParentalEnable))))
http.HandleFunc("/control/parental/disable", postInstall(optionalAuth(ensurePOST(handleParentalDisable))))
http.HandleFunc("/control/parental/status", postInstall(optionalAuth(ensureGET(handleParentalStatus))))
http.HandleFunc("/control/safesearch/enable", postInstall(optionalAuth(ensurePOST(handleSafeSearchEnable))))
http.HandleFunc("/control/safesearch/disable", postInstall(optionalAuth(ensurePOST(handleSafeSearchDisable))))
http.HandleFunc("/control/safesearch/status", postInstall(optionalAuth(ensureGET(handleSafeSearchStatus))))
http.HandleFunc("/control/dhcp/status", postInstall(optionalAuth(ensureGET(handleDHCPStatus))))
http.HandleFunc("/control/dhcp/interfaces", postInstall(optionalAuth(ensureGET(handleDHCPInterfaces))))
http.HandleFunc("/control/dhcp/set_config", postInstall(optionalAuth(ensurePOST(handleDHCPSetConfig))))
http.HandleFunc("/control/dhcp/find_active_dhcp", postInstall(optionalAuth(ensurePOST(handleDHCPFindActiveServer))))
http.HandleFunc("/control/dhcp/add_static_lease", postInstall(optionalAuth(ensurePOST(handleDHCPAddStaticLease))))
http.HandleFunc("/control/dhcp/remove_static_lease", postInstall(optionalAuth(ensurePOST(handleDHCPRemoveStaticLease))))
http.HandleFunc("/control/access/list", postInstall(optionalAuth(ensureGET(handleAccessList))))
http.HandleFunc("/control/access/set", postInstall(optionalAuth(ensurePOST(handleAccessSet))))
</s> add httpRegister(http.MethodPost, "/control/update", handleUpdate)
httpRegister(http.MethodPost, "/control/filtering/enable", handleFilteringEnable)
httpRegister(http.MethodPost, "/control/filtering/disable", handleFilteringDisable)
httpRegister(http.MethodPost, "/control/filtering/add_url", handleFilteringAddURL)
httpRegister(http.MethodPost, "/control/filtering/remove_url", handleFilteringRemoveURL)
httpRegister(http.MethodPost, "/control/filtering/enable_url", handleFilteringEnableURL)
httpRegister(http.MethodPost, "/control/filtering/disable_url", handleFilteringDisableURL)
httpRegister(http.MethodPost, "/control/filtering/refresh", handleFilteringRefresh)
httpRegister(http.MethodGet, "/control/filtering/status", handleFilteringStatus)
httpRegister(http.MethodPost, "/control/filtering/set_rules", handleFilteringSetRules)
httpRegister(http.MethodPost, "/control/safebrowsing/enable", handleSafeBrowsingEnable)
httpRegister(http.MethodPost, "/control/safebrowsing/disable", handleSafeBrowsingDisable)
httpRegister(http.MethodGet, "/control/safebrowsing/status", handleSafeBrowsingStatus)
httpRegister(http.MethodPost, "/control/parental/enable", handleParentalEnable)
httpRegister(http.MethodPost, "/control/parental/disable", handleParentalDisable)
httpRegister(http.MethodGet, "/control/parental/status", handleParentalStatus)
httpRegister(http.MethodPost, "/control/safesearch/enable", handleSafeSearchEnable)
httpRegister(http.MethodPost, "/control/safesearch/disable", handleSafeSearchDisable)
httpRegister(http.MethodGet, "/control/safesearch/status", handleSafeSearchStatus)
httpRegister(http.MethodGet, "/control/dhcp/status", handleDHCPStatus)
httpRegister(http.MethodGet, "/control/dhcp/interfaces", handleDHCPInterfaces)
httpRegister(http.MethodPost, "/control/dhcp/set_config", handleDHCPSetConfig)
httpRegister(http.MethodPost, "/control/dhcp/find_active_dhcp", handleDHCPFindActiveServer)
httpRegister(http.MethodPost, "/control/dhcp/add_static_lease", handleDHCPAddStaticLease)
httpRegister(http.MethodPost, "/control/dhcp/remove_static_lease", handleDHCPRemoveStaticLease)
httpRegister(http.MethodGet, "/control/access/list", handleAccessList)
httpRegister(http.MethodPost, "/control/access/set", handleAccessSet) </s> remove http.HandleFunc("/control/blocked_services/list", postInstall(optionalAuth(ensureGET(handleBlockedServicesList))))
http.HandleFunc("/control/blocked_services/set", postInstall(optionalAuth(ensurePOST(handleBlockedServicesSet))))
</s> add httpRegister(http.MethodGet, "/control/blocked_services/list", handleBlockedServicesList)
httpRegister(http.MethodPost, "/control/blocked_services/set", handleBlockedServicesSet) </s> remove http.HandleFunc("/control/tls/status", postInstall(optionalAuth(ensureGET(handleTLSStatus))))
http.HandleFunc("/control/tls/configure", postInstall(optionalAuth(ensurePOST(handleTLSConfigure))))
http.HandleFunc("/control/tls/validate", postInstall(optionalAuth(ensurePOST(handleTLSValidate))))
</s> add httpRegister(http.MethodGet, "/control/tls/status", handleTLSStatus)
httpRegister(http.MethodPost, "/control/tls/configure", handleTLSConfigure)
httpRegister(http.MethodPost, "/control/tls/validate", handleTLSValidate) </s> remove http.HandleFunc("/control/clients", postInstall(optionalAuth(ensureGET(handleGetClients))))
http.HandleFunc("/control/clients/add", postInstall(optionalAuth(ensurePOST(handleAddClient))))
http.HandleFunc("/control/clients/delete", postInstall(optionalAuth(ensurePOST(handleDelClient))))
http.HandleFunc("/control/clients/update", postInstall(optionalAuth(ensurePOST(handleUpdateClient))))
</s> add httpRegister(http.MethodGet, "/control/clients", handleGetClients)
httpRegister(http.MethodPost, "/control/clients/add", handleAddClient)
httpRegister(http.MethodPost, "/control/clients/delete", handleDelClient)
httpRegister(http.MethodPost, "/control/clients/update", handleUpdateClient) </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"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/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
httpRegister(http.MethodPost, "/control/update", handleUpdate)
httpRegister(http.MethodPost, "/control/filtering/enable", handleFilteringEnable)
httpRegister(http.MethodPost, "/control/filtering/disable", handleFilteringDisable)
httpRegister(http.MethodPost, "/control/filtering/add_url", handleFilteringAddURL)
httpRegister(http.MethodPost, "/control/filtering/remove_url", handleFilteringRemoveURL)
httpRegister(http.MethodPost, "/control/filtering/enable_url", handleFilteringEnableURL)
httpRegister(http.MethodPost, "/control/filtering/disable_url", handleFilteringDisableURL)
httpRegister(http.MethodPost, "/control/filtering/refresh", handleFilteringRefresh)
httpRegister(http.MethodGet, "/control/filtering/status", handleFilteringStatus)
httpRegister(http.MethodPost, "/control/filtering/set_rules", handleFilteringSetRules)
httpRegister(http.MethodPost, "/control/safebrowsing/enable", handleSafeBrowsingEnable)
httpRegister(http.MethodPost, "/control/safebrowsing/disable", handleSafeBrowsingDisable)
httpRegister(http.MethodGet, "/control/safebrowsing/status", handleSafeBrowsingStatus)
httpRegister(http.MethodPost, "/control/parental/enable", handleParentalEnable)
httpRegister(http.MethodPost, "/control/parental/disable", handleParentalDisable)
httpRegister(http.MethodGet, "/control/parental/status", handleParentalStatus)
httpRegister(http.MethodPost, "/control/safesearch/enable", handleSafeSearchEnable)
httpRegister(http.MethodPost, "/control/safesearch/disable", handleSafeSearchDisable)
httpRegister(http.MethodGet, "/control/safesearch/status", handleSafeSearchStatus)
httpRegister(http.MethodGet, "/control/dhcp/status", handleDHCPStatus)
httpRegister(http.MethodGet, "/control/dhcp/interfaces", handleDHCPInterfaces)
httpRegister(http.MethodPost, "/control/dhcp/set_config", handleDHCPSetConfig)
httpRegister(http.MethodPost, "/control/dhcp/find_active_dhcp", handleDHCPFindActiveServer)
httpRegister(http.MethodPost, "/control/dhcp/add_static_lease", handleDHCPAddStaticLease)
httpRegister(http.MethodPost, "/control/dhcp/remove_static_lease", handleDHCPRemoveStaticLease)
httpRegister(http.MethodGet, "/control/access/list", handleAccessList)
httpRegister(http.MethodPost, "/control/access/set", handleAccessSet) | <mask> http.HandleFunc("/control/stats", postInstall(optionalAuth(ensureGET(handleStats))))
<mask> http.HandleFunc("/control/stats_history", postInstall(optionalAuth(ensureGET(handleStatsHistory))))
<mask> http.HandleFunc("/control/stats_reset", postInstall(optionalAuth(ensurePOST(handleStatsReset))))
<mask> http.HandleFunc("/control/version.json", postInstall(optionalAuth(handleGetVersionJSON)))
<mask> http.HandleFunc("/control/update", postInstall(optionalAuth(ensurePOST(handleUpdate))))
<mask> http.HandleFunc("/control/filtering/enable", postInstall(optionalAuth(ensurePOST(handleFilteringEnable))))
<mask> http.HandleFunc("/control/filtering/disable", postInstall(optionalAuth(ensurePOST(handleFilteringDisable))))
<mask> http.HandleFunc("/control/filtering/add_url", postInstall(optionalAuth(ensurePOST(handleFilteringAddURL))))
<mask> http.HandleFunc("/control/filtering/remove_url", postInstall(optionalAuth(ensurePOST(handleFilteringRemoveURL))))
<mask> http.HandleFunc("/control/filtering/enable_url", postInstall(optionalAuth(ensurePOST(handleFilteringEnableURL))))
<mask> http.HandleFunc("/control/filtering/disable_url", postInstall(optionalAuth(ensurePOST(handleFilteringDisableURL))))
<mask> http.HandleFunc("/control/filtering/refresh", postInstall(optionalAuth(ensurePOST(handleFilteringRefresh))))
<mask> http.HandleFunc("/control/filtering/status", postInstall(optionalAuth(ensureGET(handleFilteringStatus))))
<mask> http.HandleFunc("/control/filtering/set_rules", postInstall(optionalAuth(ensurePOST(handleFilteringSetRules))))
<mask> http.HandleFunc("/control/safebrowsing/enable", postInstall(optionalAuth(ensurePOST(handleSafeBrowsingEnable))))
<mask> http.HandleFunc("/control/safebrowsing/disable", postInstall(optionalAuth(ensurePOST(handleSafeBrowsingDisable))))
<mask> http.HandleFunc("/control/safebrowsing/status", postInstall(optionalAuth(ensureGET(handleSafeBrowsingStatus))))
<mask> http.HandleFunc("/control/parental/enable", postInstall(optionalAuth(ensurePOST(handleParentalEnable))))
<mask> http.HandleFunc("/control/parental/disable", postInstall(optionalAuth(ensurePOST(handleParentalDisable))))
<mask> http.HandleFunc("/control/parental/status", postInstall(optionalAuth(ensureGET(handleParentalStatus))))
<mask> http.HandleFunc("/control/safesearch/enable", postInstall(optionalAuth(ensurePOST(handleSafeSearchEnable))))
<mask> http.HandleFunc("/control/safesearch/disable", postInstall(optionalAuth(ensurePOST(handleSafeSearchDisable))))
<mask> http.HandleFunc("/control/safesearch/status", postInstall(optionalAuth(ensureGET(handleSafeSearchStatus))))
<mask> http.HandleFunc("/control/dhcp/status", postInstall(optionalAuth(ensureGET(handleDHCPStatus))))
<mask> http.HandleFunc("/control/dhcp/interfaces", postInstall(optionalAuth(ensureGET(handleDHCPInterfaces))))
<mask> http.HandleFunc("/control/dhcp/set_config", postInstall(optionalAuth(ensurePOST(handleDHCPSetConfig))))
<mask> http.HandleFunc("/control/dhcp/find_active_dhcp", postInstall(optionalAuth(ensurePOST(handleDHCPFindActiveServer))))
<mask> http.HandleFunc("/control/dhcp/add_static_lease", postInstall(optionalAuth(ensurePOST(handleDHCPAddStaticLease))))
<mask> http.HandleFunc("/control/dhcp/remove_static_lease", postInstall(optionalAuth(ensurePOST(handleDHCPRemoveStaticLease))))
<mask>
<mask> http.HandleFunc("/control/access/list", postInstall(optionalAuth(ensureGET(handleAccessList))))
<mask> http.HandleFunc("/control/access/set", postInstall(optionalAuth(ensurePOST(handleAccessSet))))
<mask>
<mask> RegisterTLSHandlers()
<mask> RegisterClientsHandlers()
<mask> registerRewritesHandlers()
<mask> RegisterBlockedServicesHandlers()
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove http.HandleFunc("/control/status", postInstall(optionalAuth(ensureGET(handleStatus))))
http.HandleFunc("/control/enable_protection", postInstall(optionalAuth(ensurePOST(handleProtectionEnable))))
http.HandleFunc("/control/disable_protection", postInstall(optionalAuth(ensurePOST(handleProtectionDisable))))
http.Handle("/control/querylog", postInstallHandler(optionalAuthHandler(gziphandler.GzipHandler(ensureGETHandler(handleQueryLog)))))
http.HandleFunc("/control/querylog_enable", postInstall(optionalAuth(ensurePOST(handleQueryLogEnable))))
http.HandleFunc("/control/querylog_disable", postInstall(optionalAuth(ensurePOST(handleQueryLogDisable))))
http.HandleFunc("/control/set_upstreams_config", postInstall(optionalAuth(ensurePOST(handleSetUpstreamConfig))))
http.HandleFunc("/control/test_upstream_dns", postInstall(optionalAuth(ensurePOST(handleTestUpstreamDNS))))
http.HandleFunc("/control/i18n/change_language", postInstall(optionalAuth(ensurePOST(handleI18nChangeLanguage))))
http.HandleFunc("/control/i18n/current_language", postInstall(optionalAuth(ensureGET(handleI18nCurrentLanguage))))
http.HandleFunc("/control/stats_top", postInstall(optionalAuth(ensureGET(handleStatsTop))))
http.HandleFunc("/control/stats", postInstall(optionalAuth(ensureGET(handleStats))))
http.HandleFunc("/control/stats_history", postInstall(optionalAuth(ensureGET(handleStatsHistory))))
http.HandleFunc("/control/stats_reset", postInstall(optionalAuth(ensurePOST(handleStatsReset))))
</s> add httpRegister(http.MethodGet, "/control/status", handleStatus)
httpRegister(http.MethodPost, "/control/enable_protection", handleProtectionEnable)
httpRegister(http.MethodPost, "/control/disable_protection", handleProtectionDisable)
httpRegister(http.MethodGet, "/control/querylog", handleQueryLog)
httpRegister(http.MethodPost, "/control/querylog_enable", handleQueryLogEnable)
httpRegister(http.MethodPost, "/control/querylog_disable", handleQueryLogDisable)
httpRegister(http.MethodPost, "/control/set_upstreams_config", handleSetUpstreamConfig)
httpRegister(http.MethodPost, "/control/test_upstream_dns", handleTestUpstreamDNS)
httpRegister(http.MethodPost, "/control/i18n/change_language", handleI18nChangeLanguage)
httpRegister(http.MethodGet, "/control/i18n/current_language", handleI18nCurrentLanguage)
httpRegister(http.MethodGet, "/control/stats_top", handleStatsTop)
httpRegister(http.MethodGet, "/control/stats", handleStats)
httpRegister(http.MethodGet, "/control/stats_history", handleStatsHistory)
httpRegister(http.MethodPost, "/control/stats_reset", handleStatsReset) </s> remove http.HandleFunc("/control/rewrite/list", postInstall(optionalAuth(ensureGET(handleRewriteList))))
http.HandleFunc("/control/rewrite/add", postInstall(optionalAuth(ensurePOST(handleRewriteAdd))))
http.HandleFunc("/control/rewrite/delete", postInstall(optionalAuth(ensurePOST(handleRewriteDelete))))
</s> add httpRegister(http.MethodGet, "/control/rewrite/list", handleRewriteList)
httpRegister(http.MethodPost, "/control/rewrite/add", handleRewriteAdd)
httpRegister(http.MethodPost, "/control/rewrite/delete", handleRewriteDelete) </s> remove http.HandleFunc("/control/blocked_services/list", postInstall(optionalAuth(ensureGET(handleBlockedServicesList))))
http.HandleFunc("/control/blocked_services/set", postInstall(optionalAuth(ensurePOST(handleBlockedServicesSet))))
</s> add httpRegister(http.MethodGet, "/control/blocked_services/list", handleBlockedServicesList)
httpRegister(http.MethodPost, "/control/blocked_services/set", handleBlockedServicesSet) </s> remove http.HandleFunc("/control/clients", postInstall(optionalAuth(ensureGET(handleGetClients))))
http.HandleFunc("/control/clients/add", postInstall(optionalAuth(ensurePOST(handleAddClient))))
http.HandleFunc("/control/clients/delete", postInstall(optionalAuth(ensurePOST(handleDelClient))))
http.HandleFunc("/control/clients/update", postInstall(optionalAuth(ensurePOST(handleUpdateClient))))
</s> add httpRegister(http.MethodGet, "/control/clients", handleGetClients)
httpRegister(http.MethodPost, "/control/clients/add", handleAddClient)
httpRegister(http.MethodPost, "/control/clients/delete", handleDelClient)
httpRegister(http.MethodPost, "/control/clients/update", handleUpdateClient) </s> remove http.HandleFunc("/control/tls/status", postInstall(optionalAuth(ensureGET(handleTLSStatus))))
http.HandleFunc("/control/tls/configure", postInstall(optionalAuth(ensurePOST(handleTLSConfigure))))
http.HandleFunc("/control/tls/validate", postInstall(optionalAuth(ensurePOST(handleTLSValidate))))
</s> add httpRegister(http.MethodGet, "/control/tls/status", handleTLSStatus)
httpRegister(http.MethodPost, "/control/tls/configure", handleTLSConfigure)
httpRegister(http.MethodPost, "/control/tls/validate", handleTLSValidate) | [
"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",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control.go |
<mask> BlockedHosts []string `json:"blocked_hosts"`
<mask> }
<mask>
<mask> func handleAccessList(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> config.controlLock.Lock()
<mask> j := accessListJSON{
<mask> AllowedClients: config.DNS.AllowedClients,
<mask> DisallowedClients: config.DNS.DisallowedClients,
<mask> BlockedHosts: config.DNS.BlockedHosts,
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_access.go |
|
<mask> return nil
<mask> }
<mask>
<mask> func handleAccessSet(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> j := accessListJSON{}
<mask> err := json.NewDecoder(r.Body).Decode(&j)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "json.Decode: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_access.go |
|
<mask> }
<mask>
<mask> // Get initial installation settings
<mask> func handleInstallGetAddresses(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> data := firstRunData{}
<mask> data.WebPort = 80
<mask> data.DNSPort = 53
<mask>
<mask> ifaces, err := getValidNetInterfacesForWeb()
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_install.go |
|
<mask> }
<mask>
<mask> // Check if ports are available, respond with results
<mask> func handleInstallCheckConfig(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> reqData := checkConfigReq{}
<mask> respData := checkConfigResp{}
<mask> err := json.NewDecoder(r.Body).Decode(&reqData)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to parse 'check_config' JSON data: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_install.go |
|
<mask> }
<mask>
<mask> // Apply new configuration, start DNS server, restart Web server
<mask> func handleInstallConfigure(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> newSettings := applyConfigReq{}
<mask> err := json.NewDecoder(r.Body).Decode(&newSettings)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to parse 'configure' JSON: %s", err)
<mask> return
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_install.go |
|
httpRegister(http.MethodGet, "/control/tls/status", handleTLSStatus)
httpRegister(http.MethodPost, "/control/tls/configure", handleTLSConfigure)
httpRegister(http.MethodPost, "/control/tls/validate", handleTLSValidate) | <mask> )
<mask>
<mask> // RegisterTLSHandlers registers HTTP handlers for TLS configuration
<mask> func RegisterTLSHandlers() {
<mask> http.HandleFunc("/control/tls/status", postInstall(optionalAuth(ensureGET(handleTLSStatus))))
<mask> http.HandleFunc("/control/tls/configure", postInstall(optionalAuth(ensurePOST(handleTLSConfigure))))
<mask> http.HandleFunc("/control/tls/validate", postInstall(optionalAuth(ensurePOST(handleTLSValidate))))
<mask> }
<mask>
<mask> func handleTLSStatus(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> marshalTLS(w, config.TLS)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_tls.go |
<mask> http.HandleFunc("/control/tls/validate", postInstall(optionalAuth(ensurePOST(handleTLSValidate))))
<mask> }
<mask>
<mask> func handleTLSStatus(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> marshalTLS(w, config.TLS)
<mask> }
<mask>
<mask> func handleTLSValidate(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove http.HandleFunc("/control/tls/status", postInstall(optionalAuth(ensureGET(handleTLSStatus))))
http.HandleFunc("/control/tls/configure", postInstall(optionalAuth(ensurePOST(handleTLSConfigure))))
http.HandleFunc("/control/tls/validate", postInstall(optionalAuth(ensurePOST(handleTLSValidate))))
</s> add httpRegister(http.MethodGet, "/control/tls/status", handleTLSStatus)
httpRegister(http.MethodPost, "/control/tls/configure", handleTLSConfigure)
httpRegister(http.MethodPost, "/control/tls/validate", handleTLSValidate) </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_tls.go |
|
<mask> marshalTLS(w, config.TLS)
<mask> }
<mask>
<mask> func handleTLSValidate(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> data, err := unmarshalTLS(r)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to unmarshal TLS config: %s", err)
<mask> return
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_tls.go |
|
<mask> marshalTLS(w, data)
<mask> }
<mask>
<mask> func handleTLSConfigure(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> data, err := unmarshalTLS(r)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to unmarshal TLS config: %s", err)
<mask> return
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_tls.go |
|
<mask> }
<mask>
<mask> // Get the latest available version from the Internet
<mask> func handleGetVersionJSON(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> if config.disableUpdate {
<mask> log.Tracef("New app version check is disabled by user")
<mask> return
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("New app version check is disabled by user")
</s> add httpError(w, http.StatusInternalServerError, "New app version check is disabled by user") </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove // ---------
// filtering
// ---------
func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
data := map[string]interface{}{
"enabled": config.DNS.FilteringEnabled,
}
config.RLock()
data["filters"] = config.Filters
data["user_rules"] = config.UserRules
jsonVal, err := json.Marshal(data)
config.RUnlock()
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
}
}
func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
f := filter{}
err := json.NewDecoder(r.Body).Decode(&f)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if len(f.URL) == 0 {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(f.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// Check for duplicates
if filterExists(f.URL) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
// Set necessary properties
f.ID = assignUniqueFilterID()
f.Enabled = true
// Download the filter contents
ok, err := f.update()
if err != nil {
httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
return
}
if f.RulesCount == 0 {
httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
return
}
if !ok {
httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
return
}
// Save the filter contents
err = f.save()
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
return
}
// URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
// TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
if !filterAdd(f) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
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
}
_, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
}
}
func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
type request struct {
URL string `json:"url"`
}
req := request{}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if valid := govalidator.IsRequestURL(req.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// 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()
// go through each element and delete if url matches
config.Lock()
newFilters := config.Filters[:0]
for _, filter := range config.Filters {
if filter.URL != req.URL {
newFilters = append(newFilters, filter)
} else {
// 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
}
log.Debug("os.Remove(%s)", filter.Path())
}
}
// Update the configuration after removing filter files
config.Filters = newFilters
config.Unlock()
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, true)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, false)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
return
}
config.UserRules = strings.Split(string(body), "\n")
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
}
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_update.go |
|
httpError(w, http.StatusInternalServerError, "New app version check is disabled by user") | <mask> func handleGetVersionJSON(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> if config.disableUpdate {
<mask> log.Tracef("New app version check is disabled by user")
<mask> return
<mask> }
<mask>
<mask> req := getVersionJSONRequest{}
<mask> err := json.NewDecoder(r.Body).Decode(&req)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_update.go |
<mask> }
<mask>
<mask> // Perform an update procedure to the latest available version
<mask> func handleUpdate(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> if len(config.versionCheckJSON) == 0 {
<mask> httpError(w, http.StatusBadRequest, "/update request isn't allowed now")
<mask> return
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove // ---------
// filtering
// ---------
func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
data := map[string]interface{}{
"enabled": config.DNS.FilteringEnabled,
}
config.RLock()
data["filters"] = config.Filters
data["user_rules"] = config.UserRules
jsonVal, err := json.Marshal(data)
config.RUnlock()
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
}
}
func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
f := filter{}
err := json.NewDecoder(r.Body).Decode(&f)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if len(f.URL) == 0 {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(f.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// Check for duplicates
if filterExists(f.URL) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
// Set necessary properties
f.ID = assignUniqueFilterID()
f.Enabled = true
// Download the filter contents
ok, err := f.update()
if err != nil {
httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
return
}
if f.RulesCount == 0 {
httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
return
}
if !ok {
httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
return
}
// Save the filter contents
err = f.save()
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
return
}
// URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
// TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
if !filterAdd(f) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
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
}
_, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
}
}
func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
type request struct {
URL string `json:"url"`
}
req := request{}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if valid := govalidator.IsRequestURL(req.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// 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()
// go through each element and delete if url matches
config.Lock()
newFilters := config.Filters[:0]
for _, filter := range config.Filters {
if filter.URL != req.URL {
newFilters = append(newFilters, filter)
} else {
// 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
}
log.Debug("os.Remove(%s)", filter.Path())
}
}
// Update the configuration after removing filter files
config.Filters = newFilters
config.Unlock()
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, true)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, false)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
return
}
config.UserRules = strings.Split(string(body), "\n")
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
}
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/control_update.go |
|
<mask> return leases
<mask> }
<mask>
<mask> func handleDHCPStatus(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> leases := convertLeases(config.dhcpServer.Leases(), true)
<mask> staticLeases := convertLeases(config.dhcpServer.StaticLeases(), false)
<mask> status := map[string]interface{}{
<mask> "config": config.DHCP,
<mask> "leases": leases,
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dhcp.go |
|
<mask> StaticLeases []leaseJSON `json:"static_leases"`
<mask> }
<mask>
<mask> func handleDHCPSetConfig(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> newconfig := dhcpServerConfigJSON{}
<mask> err := json.NewDecoder(r.Body).Decode(&newconfig)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "Failed to parse new DHCP config json: %s", err)
<mask> return
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dhcp.go |
|
<mask> httpUpdateConfigReloadDNSReturnOK(w, r)
<mask> }
<mask>
<mask> func handleDHCPInterfaces(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> response := map[string]interface{}{}
<mask>
<mask> ifaces, err := getValidNetInterfaces()
<mask> if err != nil {
<mask> httpError(w, http.StatusInternalServerError, "Couldn't get interfaces: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove // ---------
// filtering
// ---------
func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
data := map[string]interface{}{
"enabled": config.DNS.FilteringEnabled,
}
config.RLock()
data["filters"] = config.Filters
data["user_rules"] = config.UserRules
jsonVal, err := json.Marshal(data)
config.RUnlock()
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
}
}
func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
f := filter{}
err := json.NewDecoder(r.Body).Decode(&f)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if len(f.URL) == 0 {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(f.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// Check for duplicates
if filterExists(f.URL) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
// Set necessary properties
f.ID = assignUniqueFilterID()
f.Enabled = true
// Download the filter contents
ok, err := f.update()
if err != nil {
httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
return
}
if f.RulesCount == 0 {
httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
return
}
if !ok {
httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
return
}
// Save the filter contents
err = f.save()
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
return
}
// URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
// TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
if !filterAdd(f) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
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
}
_, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
}
}
func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
type request struct {
URL string `json:"url"`
}
req := request{}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if valid := govalidator.IsRequestURL(req.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// 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()
// go through each element and delete if url matches
config.Lock()
newFilters := config.Filters[:0]
for _, filter := range config.Filters {
if filter.URL != req.URL {
newFilters = append(newFilters, filter)
} else {
// 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
}
log.Debug("os.Remove(%s)", filter.Path())
}
}
// Update the configuration after removing filter files
config.Filters = newFilters
config.Unlock()
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, true)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, false)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
return
}
config.UserRules = strings.Split(string(body), "\n")
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dhcp.go |
|
<mask> // . Search for another DHCP server running
<mask> // . Check if a static IP is configured for the network interface
<mask> // Respond with results
<mask> func handleDHCPFindActiveServer(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask> body, err := ioutil.ReadAll(r.Body)
<mask> if err != nil {
<mask> errorText := fmt.Sprintf("failed to read request body: %s", err)
<mask> log.Error(errorText)
<mask> http.Error(w, errorText, http.StatusBadRequest)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove // ---------
// filtering
// ---------
func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
data := map[string]interface{}{
"enabled": config.DNS.FilteringEnabled,
}
config.RLock()
data["filters"] = config.Filters
data["user_rules"] = config.UserRules
jsonVal, err := json.Marshal(data)
config.RUnlock()
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
}
}
func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
f := filter{}
err := json.NewDecoder(r.Body).Decode(&f)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if len(f.URL) == 0 {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(f.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// Check for duplicates
if filterExists(f.URL) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
// Set necessary properties
f.ID = assignUniqueFilterID()
f.Enabled = true
// Download the filter contents
ok, err := f.update()
if err != nil {
httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
return
}
if f.RulesCount == 0 {
httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
return
}
if !ok {
httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
return
}
// Save the filter contents
err = f.save()
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
return
}
// URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
// TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
if !filterAdd(f) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
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
}
_, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
}
}
func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
type request struct {
URL string `json:"url"`
}
req := request{}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if valid := govalidator.IsRequestURL(req.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// 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()
// go through each element and delete if url matches
config.Lock()
newFilters := config.Filters[:0]
for _, filter := range config.Filters {
if filter.URL != req.URL {
newFilters = append(newFilters, filter)
} else {
// 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
}
log.Debug("os.Remove(%s)", filter.Path())
}
}
// Update the configuration after removing filter files
config.Filters = newFilters
config.Unlock()
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, true)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, false)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
return
}
config.UserRules = strings.Split(string(body), "\n")
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
}
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dhcp.go |
|
<mask> return nil
<mask> }
<mask>
<mask> func handleDHCPAddStaticLease(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> lj := leaseJSON{}
<mask> err := json.NewDecoder(r.Body).Decode(&lj)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "json.Decode: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dhcp.go |
|
<mask> returnOK(w)
<mask> }
<mask>
<mask> func handleDHCPRemoveStaticLease(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> lj := leaseJSON{}
<mask> err := json.NewDecoder(r.Body).Decode(&lj)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "json.Decode: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dhcp.go |
|
<mask> Answer string `json:"answer"`
<mask> }
<mask>
<mask> func handleRewriteList(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> arr := []*rewriteEntryJSON{}
<mask>
<mask> config.RLock()
<mask> for _, ent := range config.DNS.Rewrites {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dns_rewrites.go |
|
<mask> }
<mask> }
<mask>
<mask> func handleRewriteAdd(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> jsent := rewriteEntryJSON{}
<mask> err := json.NewDecoder(r.Body).Decode(&jsent)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "json.Decode: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dns_rewrites.go |
|
<mask> returnOK(w)
<mask> }
<mask>
<mask> func handleRewriteDelete(w http.ResponseWriter, r *http.Request) {
<mask> log.Tracef("%s %v", r.Method, r.URL)
<mask>
<mask> jsent := rewriteEntryJSON{}
<mask> err := json.NewDecoder(r.Body).Decode(&jsent)
<mask> if err != nil {
<mask> httpError(w, http.StatusBadRequest, "json.Decode: %s", err)
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dns_rewrites.go |
|
httpRegister(http.MethodGet, "/control/rewrite/list", handleRewriteList)
httpRegister(http.MethodPost, "/control/rewrite/add", handleRewriteAdd)
httpRegister(http.MethodPost, "/control/rewrite/delete", handleRewriteDelete) | <mask> returnOK(w)
<mask> }
<mask>
<mask> func registerRewritesHandlers() {
<mask> http.HandleFunc("/control/rewrite/list", postInstall(optionalAuth(ensureGET(handleRewriteList))))
<mask> http.HandleFunc("/control/rewrite/add", postInstall(optionalAuth(ensurePOST(handleRewriteAdd))))
<mask> http.HandleFunc("/control/rewrite/delete", postInstall(optionalAuth(ensurePOST(handleRewriteDelete))))
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/dns_rewrites.go |
log.Debug("%s %v", r.Method, r.URL)
| <mask> func ensure(method string, handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
<mask> return func(w http.ResponseWriter, r *http.Request) {
<mask> if r.Method != method {
<mask> http.Error(w, "This request must be "+method, http.StatusMethodNotAllowed)
<mask> return
<mask> }
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove func ensureGETHandler(handler func(http.ResponseWriter, *http.Request)) http.Handler {
</s> add func ensureHandler(method string, handler func(http.ResponseWriter, *http.Request)) http.Handler { </s> remove h.handler = ensure("GET", handler)
</s> add h.handler = ensure(method, handler) </s> remove // ---------
// filtering
// ---------
func handleFilteringEnable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = true
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisable(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
config.DNS.FilteringEnabled = false
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringStatus(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
data := map[string]interface{}{
"enabled": config.DNS.FilteringEnabled,
}
config.RLock()
data["filters"] = config.Filters
data["user_rules"] = config.UserRules
jsonVal, err := json.Marshal(data)
config.RUnlock()
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
}
}
func handleFilteringAddURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
f := filter{}
err := json.NewDecoder(r.Body).Decode(&f)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if len(f.URL) == 0 {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(f.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// Check for duplicates
if filterExists(f.URL) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
// Set necessary properties
f.ID = assignUniqueFilterID()
f.Enabled = true
// Download the filter contents
ok, err := f.update()
if err != nil {
httpError(w, http.StatusBadRequest, "Couldn't fetch filter from url %s: %s", f.URL, err)
return
}
if f.RulesCount == 0 {
httpError(w, http.StatusBadRequest, "Filter at the url %s has no rules (maybe it points to blank page?)", f.URL)
return
}
if !ok {
httpError(w, http.StatusBadRequest, "Filter at the url %s is invalid (maybe it points to blank page?)", f.URL)
return
}
// Save the filter contents
err = f.save()
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to save filter %d due to %s", f.ID, err)
return
}
// URL is deemed valid, append it to filters, update config, write new filter file and tell dns to reload it
// TODO: since we directly feed filters in-memory, revisit if writing configs is always necessary
if !filterAdd(f) {
httpError(w, http.StatusBadRequest, "Filter URL already added -- %s", f.URL)
return
}
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
}
_, err = fmt.Fprintf(w, "OK %d rules\n", f.RulesCount)
if err != nil {
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
}
}
func handleFilteringRemoveURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
type request struct {
URL string `json:"url"`
}
req := request{}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to parse request body json: %s", err)
return
}
if valid := govalidator.IsRequestURL(req.URL); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
// 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()
// go through each element and delete if url matches
config.Lock()
newFilters := config.Filters[:0]
for _, filter := range config.Filters {
if filter.URL != req.URL {
newFilters = append(newFilters, filter)
} else {
// 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
}
log.Debug("os.Remove(%s)", filter.Path())
}
}
// Update the configuration after removing filter files
config.Filters = newFilters
config.Unlock()
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringEnableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, true)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringDisableURL(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
parameters, err := parseParametersFromBody(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "failed to parse parameters from body: %s", err)
return
}
url, ok := parameters["url"]
if !ok {
http.Error(w, "URL parameter was not specified", http.StatusBadRequest)
return
}
if valid := govalidator.IsRequestURL(url); !valid {
http.Error(w, "URL parameter is not valid request URL", http.StatusBadRequest)
return
}
found := filterEnable(url, false)
if !found {
http.Error(w, "URL parameter was not previously added", http.StatusBadRequest)
return
}
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringSetRules(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, http.StatusBadRequest, "Failed to read request body: %s", err)
return
}
config.UserRules = strings.Split(string(body), "\n")
httpUpdateConfigReloadDNSReturnOK(w, r)
}
func handleFilteringRefresh(w http.ResponseWriter, r *http.Request) {
log.Tracef("%s %v", r.Method, r.URL)
updated := refreshFiltersIfNecessary(true)
fmt.Fprintf(w, "OK %d filters updated\n", updated)
}
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/helpers.go |
func ensureHandler(method string, handler func(http.ResponseWriter, *http.Request)) http.Handler { | <mask> func (h *httpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
<mask> h.handler(w, r)
<mask> }
<mask>
<mask> func ensureGETHandler(handler func(http.ResponseWriter, *http.Request)) http.Handler {
<mask> h := httpHandler{}
<mask> h.handler = ensure("GET", handler)
<mask> return &h
<mask> }
<mask>
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove h.handler = ensure("GET", handler)
</s> add h.handler = ensure(method, handler) </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/helpers.go |
h.handler = ensure(method, handler) | <mask> }
<mask>
<mask> func ensureGETHandler(handler func(http.ResponseWriter, *http.Request)) http.Handler {
<mask> h := httpHandler{}
<mask> h.handler = ensure("GET", handler)
<mask> return &h
<mask> }
<mask>
<mask> func optionalAuth(handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
<mask> return func(w http.ResponseWriter, r *http.Request) {
</s> * control: refactor: all handlers are registered via httpRegister()
* move some code to home/control_filtering.go </s> remove func ensureGETHandler(handler func(http.ResponseWriter, *http.Request)) http.Handler {
</s> add func ensureHandler(method string, handler func(http.ResponseWriter, *http.Request)) http.Handler { </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add </s> remove log.Tracef("%s %v", r.Method, r.URL)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/452a668a5ba66efa265621104fe3be17ae156ed5 | home/helpers.go |
http.Handle("/", optionalAuthHandler(http.FileServer(box))) | <mask>
<mask> runStatsCollectors()
<mask> runFilterRefreshers()
<mask>
<mask> http.Handle("/", http.FileServer(box))
<mask> registerControlHandlers()
<mask>
<mask> err = startDNSServer()
<mask> if err != nil {
<mask> log.Fatal(err)
</s> Implement simple basic auth.
Closes #326. </s> remove http.HandleFunc("/control/start", ensurePOST(handleStart))
http.HandleFunc("/control/stop", ensurePOST(handleStop))
http.HandleFunc("/control/restart", ensurePOST(handleRestart))
http.HandleFunc("/control/status", ensureGET(handleStatus))
http.HandleFunc("/control/stats", ensureGET(handleStats))
http.HandleFunc("/control/stats_history", ensureGET(handleStatsHistory))
http.HandleFunc("/control/stats_top", ensureGET(handleStatsTop))
http.HandleFunc("/control/querylog", handleQueryLog)
http.HandleFunc("/control/querylog_enable", ensurePOST(handleQueryLogEnable))
http.HandleFunc("/control/querylog_disable", ensurePOST(handleQueryLogDisable))
http.HandleFunc("/control/set_upstream_dns", ensurePOST(handleSetUpstreamDNS))
http.HandleFunc("/control/filtering/enable", ensurePOST(handleFilteringEnable))
http.HandleFunc("/control/filtering/disable", ensurePOST(handleFilteringDisable))
http.HandleFunc("/control/filtering/status", ensureGET(handleFilteringStatus))
http.HandleFunc("/control/filtering/add_url", ensurePUT(handleFilteringAddURL))
http.HandleFunc("/control/filtering/remove_url", ensureDELETE(handleFilteringRemoveURL))
http.HandleFunc("/control/filtering/enable_url", ensurePOST(handleFilteringEnableURL))
http.HandleFunc("/control/filtering/disable_url", ensurePOST(handleFilteringDisableURL))
http.HandleFunc("/control/filtering/set_rules", ensurePUT(handleFilteringSetRules))
http.HandleFunc("/control/filtering/refresh", ensurePOST(handleFilteringRefresh))
http.HandleFunc("/control/safebrowsing/enable", ensurePOST(handleSafeBrowsingEnable))
http.HandleFunc("/control/safebrowsing/disable", ensurePOST(handleSafeBrowsingDisable))
http.HandleFunc("/control/safebrowsing/status", ensureGET(handleSafeBrowsingStatus))
http.HandleFunc("/control/parental/enable", ensurePOST(handleParentalEnable))
http.HandleFunc("/control/parental/disable", ensurePOST(handleParentalDisable))
http.HandleFunc("/control/parental/status", ensureGET(handleParentalStatus))
http.HandleFunc("/control/safesearch/enable", ensurePOST(handleSafeSearchEnable))
http.HandleFunc("/control/safesearch/disable", ensurePOST(handleSafeSearchDisable))
http.HandleFunc("/control/safesearch/status", ensureGET(handleSafeSearchStatus))
</s> add http.HandleFunc("/control/start", optionalAuth(ensurePOST(handleStart)))
http.HandleFunc("/control/stop", optionalAuth(ensurePOST(handleStop)))
http.HandleFunc("/control/restart", optionalAuth(ensurePOST(handleRestart)))
http.HandleFunc("/control/status", optionalAuth(ensureGET(handleStatus)))
http.HandleFunc("/control/stats", optionalAuth(ensureGET(handleStats)))
http.HandleFunc("/control/stats_history", optionalAuth(ensureGET(handleStatsHistory)))
http.HandleFunc("/control/stats_top", optionalAuth(ensureGET(handleStatsTop)))
http.HandleFunc("/control/querylog", optionalAuth(ensureGET(handleQueryLog)))
http.HandleFunc("/control/querylog_enable", optionalAuth(ensurePOST(handleQueryLogEnable)))
http.HandleFunc("/control/querylog_disable", optionalAuth(ensurePOST(handleQueryLogDisable)))
http.HandleFunc("/control/set_upstream_dns", optionalAuth(ensurePOST(handleSetUpstreamDNS)))
http.HandleFunc("/control/filtering/enable", optionalAuth(ensurePOST(handleFilteringEnable)))
http.HandleFunc("/control/filtering/disable", optionalAuth(ensurePOST(handleFilteringDisable)))
http.HandleFunc("/control/filtering/status", optionalAuth(ensureGET(handleFilteringStatus)))
http.HandleFunc("/control/filtering/add_url", optionalAuth(ensurePUT(handleFilteringAddURL)))
http.HandleFunc("/control/filtering/remove_url", optionalAuth(ensureDELETE(handleFilteringRemoveURL)))
http.HandleFunc("/control/filtering/enable_url", optionalAuth(ensurePOST(handleFilteringEnableURL)))
http.HandleFunc("/control/filtering/disable_url", optionalAuth(ensurePOST(handleFilteringDisableURL)))
http.HandleFunc("/control/filtering/set_rules", optionalAuth(ensurePUT(handleFilteringSetRules)))
http.HandleFunc("/control/filtering/refresh", optionalAuth(ensurePOST(handleFilteringRefresh)))
http.HandleFunc("/control/safebrowsing/enable", optionalAuth(ensurePOST(handleSafeBrowsingEnable)))
http.HandleFunc("/control/safebrowsing/disable", optionalAuth(ensurePOST(handleSafeBrowsingDisable)))
http.HandleFunc("/control/safebrowsing/status", optionalAuth(ensureGET(handleSafeBrowsingStatus)))
http.HandleFunc("/control/parental/enable", optionalAuth(ensurePOST(handleParentalEnable)))
http.HandleFunc("/control/parental/disable", optionalAuth(ensurePOST(handleParentalDisable)))
http.HandleFunc("/control/parental/status", optionalAuth(ensureGET(handleParentalStatus)))
http.HandleFunc("/control/safesearch/enable", optionalAuth(ensurePOST(handleSafeSearchEnable)))
http.HandleFunc("/control/safesearch/disable", optionalAuth(ensurePOST(handleSafeSearchDisable)))
http.HandleFunc("/control/safesearch/status", optionalAuth(ensureGET(handleSafeSearchStatus))) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4548eb8d118c75749a3916bde022ebe4b13a7ef4 | app.go |
AuthName string `yaml:"auth_name"`
AuthPass string `yaml:"auth_pass"` | <mask>
<mask> BindHost string `yaml:"bind_host"`
<mask> BindPort int `yaml:"bind_port"`
<mask> CoreDNS coreDNSConfig `yaml:"coredns"`
<mask> Filters []filter `yaml:"filters"`
<mask> UserRules []string `yaml:"user_rules"`
<mask>
<mask> sync.Mutex `yaml:"-"`
</s> Implement simple basic auth.
Closes #326. </s> remove http.HandleFunc("/control/start", ensurePOST(handleStart))
http.HandleFunc("/control/stop", ensurePOST(handleStop))
http.HandleFunc("/control/restart", ensurePOST(handleRestart))
http.HandleFunc("/control/status", ensureGET(handleStatus))
http.HandleFunc("/control/stats", ensureGET(handleStats))
http.HandleFunc("/control/stats_history", ensureGET(handleStatsHistory))
http.HandleFunc("/control/stats_top", ensureGET(handleStatsTop))
http.HandleFunc("/control/querylog", handleQueryLog)
http.HandleFunc("/control/querylog_enable", ensurePOST(handleQueryLogEnable))
http.HandleFunc("/control/querylog_disable", ensurePOST(handleQueryLogDisable))
http.HandleFunc("/control/set_upstream_dns", ensurePOST(handleSetUpstreamDNS))
http.HandleFunc("/control/filtering/enable", ensurePOST(handleFilteringEnable))
http.HandleFunc("/control/filtering/disable", ensurePOST(handleFilteringDisable))
http.HandleFunc("/control/filtering/status", ensureGET(handleFilteringStatus))
http.HandleFunc("/control/filtering/add_url", ensurePUT(handleFilteringAddURL))
http.HandleFunc("/control/filtering/remove_url", ensureDELETE(handleFilteringRemoveURL))
http.HandleFunc("/control/filtering/enable_url", ensurePOST(handleFilteringEnableURL))
http.HandleFunc("/control/filtering/disable_url", ensurePOST(handleFilteringDisableURL))
http.HandleFunc("/control/filtering/set_rules", ensurePUT(handleFilteringSetRules))
http.HandleFunc("/control/filtering/refresh", ensurePOST(handleFilteringRefresh))
http.HandleFunc("/control/safebrowsing/enable", ensurePOST(handleSafeBrowsingEnable))
http.HandleFunc("/control/safebrowsing/disable", ensurePOST(handleSafeBrowsingDisable))
http.HandleFunc("/control/safebrowsing/status", ensureGET(handleSafeBrowsingStatus))
http.HandleFunc("/control/parental/enable", ensurePOST(handleParentalEnable))
http.HandleFunc("/control/parental/disable", ensurePOST(handleParentalDisable))
http.HandleFunc("/control/parental/status", ensureGET(handleParentalStatus))
http.HandleFunc("/control/safesearch/enable", ensurePOST(handleSafeSearchEnable))
http.HandleFunc("/control/safesearch/disable", ensurePOST(handleSafeSearchDisable))
http.HandleFunc("/control/safesearch/status", ensureGET(handleSafeSearchStatus))
</s> add http.HandleFunc("/control/start", optionalAuth(ensurePOST(handleStart)))
http.HandleFunc("/control/stop", optionalAuth(ensurePOST(handleStop)))
http.HandleFunc("/control/restart", optionalAuth(ensurePOST(handleRestart)))
http.HandleFunc("/control/status", optionalAuth(ensureGET(handleStatus)))
http.HandleFunc("/control/stats", optionalAuth(ensureGET(handleStats)))
http.HandleFunc("/control/stats_history", optionalAuth(ensureGET(handleStatsHistory)))
http.HandleFunc("/control/stats_top", optionalAuth(ensureGET(handleStatsTop)))
http.HandleFunc("/control/querylog", optionalAuth(ensureGET(handleQueryLog)))
http.HandleFunc("/control/querylog_enable", optionalAuth(ensurePOST(handleQueryLogEnable)))
http.HandleFunc("/control/querylog_disable", optionalAuth(ensurePOST(handleQueryLogDisable)))
http.HandleFunc("/control/set_upstream_dns", optionalAuth(ensurePOST(handleSetUpstreamDNS)))
http.HandleFunc("/control/filtering/enable", optionalAuth(ensurePOST(handleFilteringEnable)))
http.HandleFunc("/control/filtering/disable", optionalAuth(ensurePOST(handleFilteringDisable)))
http.HandleFunc("/control/filtering/status", optionalAuth(ensureGET(handleFilteringStatus)))
http.HandleFunc("/control/filtering/add_url", optionalAuth(ensurePUT(handleFilteringAddURL)))
http.HandleFunc("/control/filtering/remove_url", optionalAuth(ensureDELETE(handleFilteringRemoveURL)))
http.HandleFunc("/control/filtering/enable_url", optionalAuth(ensurePOST(handleFilteringEnableURL)))
http.HandleFunc("/control/filtering/disable_url", optionalAuth(ensurePOST(handleFilteringDisableURL)))
http.HandleFunc("/control/filtering/set_rules", optionalAuth(ensurePUT(handleFilteringSetRules)))
http.HandleFunc("/control/filtering/refresh", optionalAuth(ensurePOST(handleFilteringRefresh)))
http.HandleFunc("/control/safebrowsing/enable", optionalAuth(ensurePOST(handleSafeBrowsingEnable)))
http.HandleFunc("/control/safebrowsing/disable", optionalAuth(ensurePOST(handleSafeBrowsingDisable)))
http.HandleFunc("/control/safebrowsing/status", optionalAuth(ensureGET(handleSafeBrowsingStatus)))
http.HandleFunc("/control/parental/enable", optionalAuth(ensurePOST(handleParentalEnable)))
http.HandleFunc("/control/parental/disable", optionalAuth(ensurePOST(handleParentalDisable)))
http.HandleFunc("/control/parental/status", optionalAuth(ensureGET(handleParentalStatus)))
http.HandleFunc("/control/safesearch/enable", optionalAuth(ensurePOST(handleSafeSearchEnable)))
http.HandleFunc("/control/safesearch/disable", optionalAuth(ensurePOST(handleSafeSearchDisable)))
http.HandleFunc("/control/safesearch/status", optionalAuth(ensureGET(handleSafeSearchStatus))) </s> remove http.Handle("/", http.FileServer(box))
</s> add http.Handle("/", optionalAuthHandler(http.FileServer(box))) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4548eb8d118c75749a3916bde022ebe4b13a7ef4 | config.go |
http.HandleFunc("/control/start", optionalAuth(ensurePOST(handleStart)))
http.HandleFunc("/control/stop", optionalAuth(ensurePOST(handleStop)))
http.HandleFunc("/control/restart", optionalAuth(ensurePOST(handleRestart)))
http.HandleFunc("/control/status", optionalAuth(ensureGET(handleStatus)))
http.HandleFunc("/control/stats", optionalAuth(ensureGET(handleStats)))
http.HandleFunc("/control/stats_history", optionalAuth(ensureGET(handleStatsHistory)))
http.HandleFunc("/control/stats_top", optionalAuth(ensureGET(handleStatsTop)))
http.HandleFunc("/control/querylog", optionalAuth(ensureGET(handleQueryLog)))
http.HandleFunc("/control/querylog_enable", optionalAuth(ensurePOST(handleQueryLogEnable)))
http.HandleFunc("/control/querylog_disable", optionalAuth(ensurePOST(handleQueryLogDisable)))
http.HandleFunc("/control/set_upstream_dns", optionalAuth(ensurePOST(handleSetUpstreamDNS)))
http.HandleFunc("/control/filtering/enable", optionalAuth(ensurePOST(handleFilteringEnable)))
http.HandleFunc("/control/filtering/disable", optionalAuth(ensurePOST(handleFilteringDisable)))
http.HandleFunc("/control/filtering/status", optionalAuth(ensureGET(handleFilteringStatus)))
http.HandleFunc("/control/filtering/add_url", optionalAuth(ensurePUT(handleFilteringAddURL)))
http.HandleFunc("/control/filtering/remove_url", optionalAuth(ensureDELETE(handleFilteringRemoveURL)))
http.HandleFunc("/control/filtering/enable_url", optionalAuth(ensurePOST(handleFilteringEnableURL)))
http.HandleFunc("/control/filtering/disable_url", optionalAuth(ensurePOST(handleFilteringDisableURL)))
http.HandleFunc("/control/filtering/set_rules", optionalAuth(ensurePUT(handleFilteringSetRules)))
http.HandleFunc("/control/filtering/refresh", optionalAuth(ensurePOST(handleFilteringRefresh)))
http.HandleFunc("/control/safebrowsing/enable", optionalAuth(ensurePOST(handleSafeBrowsingEnable)))
http.HandleFunc("/control/safebrowsing/disable", optionalAuth(ensurePOST(handleSafeBrowsingDisable)))
http.HandleFunc("/control/safebrowsing/status", optionalAuth(ensureGET(handleSafeBrowsingStatus)))
http.HandleFunc("/control/parental/enable", optionalAuth(ensurePOST(handleParentalEnable)))
http.HandleFunc("/control/parental/disable", optionalAuth(ensurePOST(handleParentalDisable)))
http.HandleFunc("/control/parental/status", optionalAuth(ensureGET(handleParentalStatus)))
http.HandleFunc("/control/safesearch/enable", optionalAuth(ensurePOST(handleSafeSearchEnable)))
http.HandleFunc("/control/safesearch/disable", optionalAuth(ensurePOST(handleSafeSearchDisable)))
http.HandleFunc("/control/safesearch/status", optionalAuth(ensureGET(handleSafeSearchStatus))) | <mask> }
<mask> }
<mask>
<mask> func registerControlHandlers() {
<mask> http.HandleFunc("/control/start", ensurePOST(handleStart))
<mask> http.HandleFunc("/control/stop", ensurePOST(handleStop))
<mask> http.HandleFunc("/control/restart", ensurePOST(handleRestart))
<mask> http.HandleFunc("/control/status", ensureGET(handleStatus))
<mask> http.HandleFunc("/control/stats", ensureGET(handleStats))
<mask> http.HandleFunc("/control/stats_history", ensureGET(handleStatsHistory))
<mask> http.HandleFunc("/control/stats_top", ensureGET(handleStatsTop))
<mask> http.HandleFunc("/control/querylog", handleQueryLog)
<mask> http.HandleFunc("/control/querylog_enable", ensurePOST(handleQueryLogEnable))
<mask> http.HandleFunc("/control/querylog_disable", ensurePOST(handleQueryLogDisable))
<mask> http.HandleFunc("/control/set_upstream_dns", ensurePOST(handleSetUpstreamDNS))
<mask> http.HandleFunc("/control/filtering/enable", ensurePOST(handleFilteringEnable))
<mask> http.HandleFunc("/control/filtering/disable", ensurePOST(handleFilteringDisable))
<mask> http.HandleFunc("/control/filtering/status", ensureGET(handleFilteringStatus))
<mask> http.HandleFunc("/control/filtering/add_url", ensurePUT(handleFilteringAddURL))
<mask> http.HandleFunc("/control/filtering/remove_url", ensureDELETE(handleFilteringRemoveURL))
<mask> http.HandleFunc("/control/filtering/enable_url", ensurePOST(handleFilteringEnableURL))
<mask> http.HandleFunc("/control/filtering/disable_url", ensurePOST(handleFilteringDisableURL))
<mask> http.HandleFunc("/control/filtering/set_rules", ensurePUT(handleFilteringSetRules))
<mask> http.HandleFunc("/control/filtering/refresh", ensurePOST(handleFilteringRefresh))
<mask> http.HandleFunc("/control/safebrowsing/enable", ensurePOST(handleSafeBrowsingEnable))
<mask> http.HandleFunc("/control/safebrowsing/disable", ensurePOST(handleSafeBrowsingDisable))
<mask> http.HandleFunc("/control/safebrowsing/status", ensureGET(handleSafeBrowsingStatus))
<mask> http.HandleFunc("/control/parental/enable", ensurePOST(handleParentalEnable))
<mask> http.HandleFunc("/control/parental/disable", ensurePOST(handleParentalDisable))
<mask> http.HandleFunc("/control/parental/status", ensureGET(handleParentalStatus))
<mask> http.HandleFunc("/control/safesearch/enable", ensurePOST(handleSafeSearchEnable))
<mask> http.HandleFunc("/control/safesearch/disable", ensurePOST(handleSafeSearchDisable))
<mask> http.HandleFunc("/control/safesearch/status", ensureGET(handleSafeSearchStatus))
<mask> }
</s> Implement simple basic auth.
Closes #326. </s> remove http.Handle("/", http.FileServer(box))
</s> add http.Handle("/", optionalAuthHandler(http.FileServer(box))) | [
"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",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4548eb8d118c75749a3916bde022ebe4b13a7ef4 | control.go |
"net/netip" | <mask> "bytes"
<mask> "fmt"
<mask> "net"
<mask> "os"
<mask> "time"
<mask>
<mask> "github.com/AdguardTeam/golibs/errors"
</s> Pull request: Migrate to netip.Addr vol.1
Merge in DNS/adguard-home from 2926-lla-v6 to master
Updates #2926.
Updates #5035.
Squashed commit of the following:
commit 2e770d4b6d4e1ec3f7762f2f2466662983bf146c
Merge: 25c1afc5 893358ea
Author: Eugene Burkov <[email protected]>
Date: Fri Oct 14 15:14:56 2022 +0300
Merge branch 'master' into 2926-lla-v6
commit 25c1afc5f0a5027fafac9dee77618886aefee29c
Author: Eugene Burkov <[email protected]>
Date: Thu Oct 13 18:24:20 2022 +0300
all: imp code, docs
commit 59549c4f74ee17b10eae542d1f1828d4e59894c9
Author: Eugene Burkov <[email protected]>
Date: Tue Oct 11 18:49:09 2022 +0300
dhcpd: use netip initially
commit 1af623096b0517d07752385540f2f750f7f5b3bb
Author: Eugene Burkov <[email protected]>
Date: Fri Sep 30 18:03:52 2022 +0300
all: imp docs, code
commit e9faeb71dbc0e887b25a7f3d5b33a401805f2ae7
Author: Eugene Burkov <[email protected]>
Date: Thu Sep 29 14:56:37 2022 +0300
all: use netip for web
commit 38305e555a6884c3bd1b0839330b942ce0e59093
Author: Eugene Burkov <[email protected]>
Date: Wed Sep 28 19:13:58 2022 +0300
add basic lla </s> remove "net"
</s> add "net/netip" </s> remove "net"
</s> add "net/netip" | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4582b1c9198dcbc1927b74080839e81ba347265a | internal/aghnet/dhcp_unix.go |
func ifaceIPv4Subnet(iface *net.Interface) (subnet netip.Prefix, err error) { | <mask> return ok4, ok6, err4, err6
<mask> }
<mask>
<mask> // ifaceIPv4Subnet returns the first suitable IPv4 subnetwork iface has.
<mask> func ifaceIPv4Subnet(iface *net.Interface) (subnet *net.IPNet, err error) {
<mask> var addrs []net.Addr
<mask> if addrs, err = iface.Addrs(); err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Pull request: Migrate to netip.Addr vol.1
Merge in DNS/adguard-home from 2926-lla-v6 to master
Updates #2926.
Updates #5035.
Squashed commit of the following:
commit 2e770d4b6d4e1ec3f7762f2f2466662983bf146c
Merge: 25c1afc5 893358ea
Author: Eugene Burkov <[email protected]>
Date: Fri Oct 14 15:14:56 2022 +0300
Merge branch 'master' into 2926-lla-v6
commit 25c1afc5f0a5027fafac9dee77618886aefee29c
Author: Eugene Burkov <[email protected]>
Date: Thu Oct 13 18:24:20 2022 +0300
all: imp code, docs
commit 59549c4f74ee17b10eae542d1f1828d4e59894c9
Author: Eugene Burkov <[email protected]>
Date: Tue Oct 11 18:49:09 2022 +0300
dhcpd: use netip initially
commit 1af623096b0517d07752385540f2f750f7f5b3bb
Author: Eugene Burkov <[email protected]>
Date: Fri Sep 30 18:03:52 2022 +0300
all: imp docs, code
commit e9faeb71dbc0e887b25a7f3d5b33a401805f2ae7
Author: Eugene Burkov <[email protected]>
Date: Thu Sep 29 14:56:37 2022 +0300
all: use netip for web
commit 38305e555a6884c3bd1b0839330b942ce0e59093
Author: Eugene Burkov <[email protected]>
Date: Wed Sep 28 19:13:58 2022 +0300
add basic lla </s> remove return nil, err
</s> add return netip.Prefix{}, err </s> remove return nil, fmt.Errorf("couldn't get interfaces: %w", err)
} else if len(ifaces) == 0 {
return nil, errors.Error("couldn't find any legible interface")
</s> add return nil, fmt.Errorf("failed to get addresses for interface %s: %w", iface.Name, err) </s> remove for _, iface := range ifaces {
var addrs []net.Addr
addrs, err = iface.Addrs()
if err != nil {
return nil, fmt.Errorf("failed to get addresses for interface %s: %w", iface.Name, err)
</s> add // Collect network interface addresses.
for _, addr := range addrs {
n, ok := addr.(*net.IPNet)
if !ok {
// Should be *net.IPNet, this is weird.
return nil, fmt.Errorf("expected %[2]s to be %[1]T, got %[2]T", n, addr)
} else if ip4 := n.IP.To4(); ip4 != nil {
n.IP = ip4 </s> remove addrs = appendDNSAddrs(addrs, net.IP{127, 0, 0, 1})
</s> add addr := aghnet.IPv4Localhost()
addrs = appendDNSAddrs(addrs, addr) </s> remove // GetValidNetInterfacesForWeb returns interfaces that are eligible for DNS and
// WEB only we do not return link-local addresses here.
//
// TODO(e.burkov): Can't properly test the function since it's nontrivial to
// substitute net.Interface.Addrs and the net.InterfaceAddrs can't be used.
func GetValidNetInterfacesForWeb() (netIfaces []*NetInterface, err error) {
ifaces, err := net.Interfaces()
</s> add func NetInterfaceFrom(iface *net.Interface) (niface *NetInterface, err error) {
niface = &NetInterface{
Name: iface.Name,
HardwareAddr: iface.HardwareAddr,
Flags: iface.Flags,
MTU: iface.MTU,
}
addrs, err := iface.Addrs() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4582b1c9198dcbc1927b74080839e81ba347265a | internal/aghnet/dhcp_unix.go |
return netip.Prefix{}, err | <mask> // ifaceIPv4Subnet returns the first suitable IPv4 subnetwork iface has.
<mask> func ifaceIPv4Subnet(iface *net.Interface) (subnet *net.IPNet, err error) {
<mask> var addrs []net.Addr
<mask> if addrs, err = iface.Addrs(); err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> for _, a := range addrs {
<mask> switch a := a.(type) {
<mask> case *net.IPAddr:
</s> Pull request: Migrate to netip.Addr vol.1
Merge in DNS/adguard-home from 2926-lla-v6 to master
Updates #2926.
Updates #5035.
Squashed commit of the following:
commit 2e770d4b6d4e1ec3f7762f2f2466662983bf146c
Merge: 25c1afc5 893358ea
Author: Eugene Burkov <[email protected]>
Date: Fri Oct 14 15:14:56 2022 +0300
Merge branch 'master' into 2926-lla-v6
commit 25c1afc5f0a5027fafac9dee77618886aefee29c
Author: Eugene Burkov <[email protected]>
Date: Thu Oct 13 18:24:20 2022 +0300
all: imp code, docs
commit 59549c4f74ee17b10eae542d1f1828d4e59894c9
Author: Eugene Burkov <[email protected]>
Date: Tue Oct 11 18:49:09 2022 +0300
dhcpd: use netip initially
commit 1af623096b0517d07752385540f2f750f7f5b3bb
Author: Eugene Burkov <[email protected]>
Date: Fri Sep 30 18:03:52 2022 +0300
all: imp docs, code
commit e9faeb71dbc0e887b25a7f3d5b33a401805f2ae7
Author: Eugene Burkov <[email protected]>
Date: Thu Sep 29 14:56:37 2022 +0300
all: use netip for web
commit 38305e555a6884c3bd1b0839330b942ce0e59093
Author: Eugene Burkov <[email protected]>
Date: Wed Sep 28 19:13:58 2022 +0300
add basic lla </s> remove func ifaceIPv4Subnet(iface *net.Interface) (subnet *net.IPNet, err error) {
</s> add func ifaceIPv4Subnet(iface *net.Interface) (subnet netip.Prefix, err error) { </s> remove subnet = &net.IPNet{
IP: a.IP,
Mask: a.IP.DefaultMask(),
}
</s> add ip = a.IP
maskLen, _ = ip.DefaultMask().Size() </s> remove return nil, fmt.Errorf("couldn't get interfaces: %w", err)
} else if len(ifaces) == 0 {
return nil, errors.Error("couldn't find any legible interface")
</s> add return nil, fmt.Errorf("failed to get addresses for interface %s: %w", iface.Name, err) </s> remove for _, iface := range ifaces {
var addrs []net.Addr
addrs, err = iface.Addrs()
if err != nil {
return nil, fmt.Errorf("failed to get addresses for interface %s: %w", iface.Name, err)
</s> add // Collect network interface addresses.
for _, addr := range addrs {
n, ok := addr.(*net.IPNet)
if !ok {
// Should be *net.IPNet, this is weird.
return nil, fmt.Errorf("expected %[2]s to be %[1]T, got %[2]T", n, addr)
} else if ip4 := n.IP.To4(); ip4 != nil {
n.IP = ip4 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4582b1c9198dcbc1927b74080839e81ba347265a | internal/aghnet/dhcp_unix.go |
var ip net.IP
var maskLen int | <mask> }
<mask>
<mask> for _, a := range addrs {
<mask> switch a := a.(type) {
<mask> case *net.IPAddr:
<mask> ip = a.IP
<mask> maskLen, _ = ip.DefaultMask().Size()
<mask> case *net.IPNet:
</s> Pull request: Migrate to netip.Addr vol.1
Merge in DNS/adguard-home from 2926-lla-v6 to master
Updates #2926.
Updates #5035.
Squashed commit of the following:
commit 2e770d4b6d4e1ec3f7762f2f2466662983bf146c
Merge: 25c1afc5 893358ea
Author: Eugene Burkov <[email protected]>
Date: Fri Oct 14 15:14:56 2022 +0300
Merge branch 'master' into 2926-lla-v6
commit 25c1afc5f0a5027fafac9dee77618886aefee29c
Author: Eugene Burkov <[email protected]>
Date: Thu Oct 13 18:24:20 2022 +0300
all: imp code, docs
commit 59549c4f74ee17b10eae542d1f1828d4e59894c9
Author: Eugene Burkov <[email protected]>
Date: Tue Oct 11 18:49:09 2022 +0300
dhcpd: use netip initially
commit 1af623096b0517d07752385540f2f750f7f5b3bb
Author: Eugene Burkov <[email protected]>
Date: Fri Sep 30 18:03:52 2022 +0300
all: imp docs, code
commit e9faeb71dbc0e887b25a7f3d5b33a401805f2ae7
Author: Eugene Burkov <[email protected]>
Date: Thu Sep 29 14:56:37 2022 +0300
all: use netip for web
commit 38305e555a6884c3bd1b0839330b942ce0e59093
Author: Eugene Burkov <[email protected]>
Date: Wed Sep 28 19:13:58 2022 +0300
add basic lla </s> remove subnet = &net.IPNet{
IP: a.IP,
Mask: a.IP.DefaultMask(),
}
</s> add ip = a.IP
maskLen, _ = ip.DefaultMask().Size() </s> remove subnet = a
</s> add ip = a.IP
maskLen, _ = a.Mask.Size() </s> remove return nil, err
</s> add return netip.Prefix{}, err </s> remove func appendDNSAddrs(dst []string, addrs ...net.IP) (res []string) {
</s> add func appendDNSAddrs(dst []string, addrs ...netip.Addr) (res []string) { </s> remove addr := netutil.IPPort{IP: ip, Port: port}.String()
</s> add addr := ipp.String() | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/AdguardTeam/AdGuardHome/commit/4582b1c9198dcbc1927b74080839e81ba347265a | internal/aghnet/dhcp_unix.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.