mirror of
https://github.com/AdguardTeam/AdGuardHome.git
synced 2024-12-16 20:24:15 +03:00
d83091fc1f
Updates #2961. Squashed commit of the following: commit 207eeb85caf6caee81a669302daf4e10a5b61585 Author: Ainar Garipov <A.Garipov@AdGuard.COM> Date: Thu Apr 15 18:48:50 2021 +0300 all: allow local non-top-level domains
304 lines
7.8 KiB
Go
304 lines
7.8 KiB
Go
package home
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
)
|
|
|
|
type clientJSON struct {
|
|
IDs []string `json:"ids"`
|
|
Tags []string `json:"tags"`
|
|
Name string `json:"name"`
|
|
UseGlobalSettings bool `json:"use_global_settings"`
|
|
FilteringEnabled bool `json:"filtering_enabled"`
|
|
ParentalEnabled bool `json:"parental_enabled"`
|
|
SafeSearchEnabled bool `json:"safesearch_enabled"`
|
|
SafeBrowsingEnabled bool `json:"safebrowsing_enabled"`
|
|
|
|
UseGlobalBlockedServices bool `json:"use_global_blocked_services"`
|
|
BlockedServices []string `json:"blocked_services"`
|
|
|
|
Upstreams []string `json:"upstreams"`
|
|
|
|
WhoisInfo *RuntimeClientWhoisInfo `json:"whois_info"`
|
|
|
|
// Disallowed - if true -- client's IP is not disallowed
|
|
// Otherwise, it is blocked.
|
|
Disallowed bool `json:"disallowed"`
|
|
|
|
// DisallowedRule - the rule due to which the client is disallowed
|
|
// If Disallowed is true, and this string is empty - it means that the client IP
|
|
// is disallowed by the "allowed IP list", i.e. it is not included in allowed.
|
|
DisallowedRule string `json:"disallowed_rule"`
|
|
}
|
|
|
|
type runtimeClientJSON struct {
|
|
WhoisInfo *RuntimeClientWhoisInfo `json:"whois_info"`
|
|
|
|
IP string `json:"ip"`
|
|
Name string `json:"name"`
|
|
Source string `json:"source"`
|
|
}
|
|
|
|
type clientListJSON struct {
|
|
Clients []clientJSON `json:"clients"`
|
|
RuntimeClients []runtimeClientJSON `json:"auto_clients"`
|
|
Tags []string `json:"supported_tags"`
|
|
}
|
|
|
|
// respond with information about configured clients
|
|
func (clients *clientsContainer) handleGetClients(w http.ResponseWriter, _ *http.Request) {
|
|
data := clientListJSON{}
|
|
|
|
clients.lock.Lock()
|
|
defer clients.lock.Unlock()
|
|
|
|
for _, c := range clients.list {
|
|
cj := clientToJSON(c)
|
|
data.Clients = append(data.Clients, cj)
|
|
}
|
|
for ip, rc := range clients.ipToRC {
|
|
cj := runtimeClientJSON{
|
|
IP: ip,
|
|
Name: rc.Host,
|
|
WhoisInfo: rc.WhoisInfo,
|
|
}
|
|
|
|
cj.Source = "etc/hosts"
|
|
switch rc.Source {
|
|
case ClientSourceDHCP:
|
|
cj.Source = "DHCP"
|
|
case ClientSourceRDNS:
|
|
cj.Source = "rDNS"
|
|
case ClientSourceARP:
|
|
cj.Source = "ARP"
|
|
case ClientSourceWHOIS:
|
|
cj.Source = "WHOIS"
|
|
}
|
|
|
|
data.RuntimeClients = append(data.RuntimeClients, cj)
|
|
}
|
|
|
|
data.Tags = clientTags
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
e := json.NewEncoder(w).Encode(data)
|
|
if e != nil {
|
|
httpError(w, http.StatusInternalServerError, "Failed to encode to json: %v", e)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Convert JSON object to Client object
|
|
func jsonToClient(cj clientJSON) (c *Client) {
|
|
return &Client{
|
|
Name: cj.Name,
|
|
IDs: cj.IDs,
|
|
Tags: cj.Tags,
|
|
UseOwnSettings: !cj.UseGlobalSettings,
|
|
FilteringEnabled: cj.FilteringEnabled,
|
|
ParentalEnabled: cj.ParentalEnabled,
|
|
SafeSearchEnabled: cj.SafeSearchEnabled,
|
|
SafeBrowsingEnabled: cj.SafeBrowsingEnabled,
|
|
|
|
UseOwnBlockedServices: !cj.UseGlobalBlockedServices,
|
|
BlockedServices: cj.BlockedServices,
|
|
|
|
Upstreams: cj.Upstreams,
|
|
}
|
|
}
|
|
|
|
// Convert Client object to JSON
|
|
func clientToJSON(c *Client) clientJSON {
|
|
cj := clientJSON{
|
|
Name: c.Name,
|
|
IDs: c.IDs,
|
|
Tags: c.Tags,
|
|
UseGlobalSettings: !c.UseOwnSettings,
|
|
FilteringEnabled: c.FilteringEnabled,
|
|
ParentalEnabled: c.ParentalEnabled,
|
|
SafeSearchEnabled: c.SafeSearchEnabled,
|
|
SafeBrowsingEnabled: c.SafeBrowsingEnabled,
|
|
|
|
UseGlobalBlockedServices: !c.UseOwnBlockedServices,
|
|
BlockedServices: c.BlockedServices,
|
|
|
|
Upstreams: c.Upstreams,
|
|
|
|
WhoisInfo: &RuntimeClientWhoisInfo{},
|
|
}
|
|
|
|
return cj
|
|
}
|
|
|
|
// runtimeClientToJSON converts a RuntimeClient into a JSON struct.
|
|
func runtimeClientToJSON(ip string, rc RuntimeClient) (cj clientJSON) {
|
|
cj = clientJSON{
|
|
Name: rc.Host,
|
|
IDs: []string{ip},
|
|
WhoisInfo: rc.WhoisInfo,
|
|
}
|
|
|
|
return cj
|
|
}
|
|
|
|
// Add a new client
|
|
func (clients *clientsContainer) handleAddClient(w http.ResponseWriter, r *http.Request) {
|
|
cj := clientJSON{}
|
|
err := json.NewDecoder(r.Body).Decode(&cj)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "failed to process request body: %s", err)
|
|
|
|
return
|
|
}
|
|
|
|
c := jsonToClient(cj)
|
|
ok, err := clients.Add(c)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "%s", err)
|
|
return
|
|
}
|
|
if !ok {
|
|
httpError(w, http.StatusBadRequest, "Client already exists")
|
|
return
|
|
}
|
|
|
|
onConfigModified()
|
|
}
|
|
|
|
// Remove client
|
|
func (clients *clientsContainer) handleDelClient(w http.ResponseWriter, r *http.Request) {
|
|
cj := clientJSON{}
|
|
err := json.NewDecoder(r.Body).Decode(&cj)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "failed to process request body: %s", err)
|
|
|
|
return
|
|
}
|
|
|
|
if len(cj.Name) == 0 {
|
|
httpError(w, http.StatusBadRequest, "client's name must be non-empty")
|
|
|
|
return
|
|
}
|
|
|
|
if !clients.Del(cj.Name) {
|
|
httpError(w, http.StatusBadRequest, "Client not found")
|
|
return
|
|
}
|
|
|
|
onConfigModified()
|
|
}
|
|
|
|
type updateJSON struct {
|
|
Name string `json:"name"`
|
|
Data clientJSON `json:"data"`
|
|
}
|
|
|
|
// Update client's properties
|
|
func (clients *clientsContainer) handleUpdateClient(w http.ResponseWriter, r *http.Request) {
|
|
dj := updateJSON{}
|
|
err := json.NewDecoder(r.Body).Decode(&dj)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "failed to process request body: %s", err)
|
|
|
|
return
|
|
}
|
|
|
|
if len(dj.Name) == 0 {
|
|
httpError(w, http.StatusBadRequest, "Invalid request")
|
|
return
|
|
}
|
|
|
|
c := jsonToClient(dj.Data)
|
|
err = clients.Update(dj.Name, c)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "%s", err)
|
|
return
|
|
}
|
|
|
|
onConfigModified()
|
|
}
|
|
|
|
// Get the list of clients by IP address list
|
|
func (clients *clientsContainer) handleFindClient(w http.ResponseWriter, r *http.Request) {
|
|
q := r.URL.Query()
|
|
data := []map[string]clientJSON{}
|
|
for i := 0; i < len(q); i++ {
|
|
idStr := q.Get(fmt.Sprintf("ip%d", i))
|
|
if idStr == "" {
|
|
break
|
|
}
|
|
|
|
ip := net.ParseIP(idStr)
|
|
c, ok := clients.Find(idStr)
|
|
var cj clientJSON
|
|
if !ok {
|
|
var found bool
|
|
cj, found = clients.findRuntime(ip, idStr)
|
|
if !found {
|
|
continue
|
|
}
|
|
} else {
|
|
cj = clientToJSON(c)
|
|
cj.Disallowed, cj.DisallowedRule = clients.dnsServer.IsBlockedIP(ip)
|
|
}
|
|
|
|
data = append(data, map[string]clientJSON{
|
|
idStr: cj,
|
|
})
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
err := json.NewEncoder(w).Encode(data)
|
|
if err != nil {
|
|
httpError(w, http.StatusInternalServerError, "Couldn't write response: %s", err)
|
|
}
|
|
}
|
|
|
|
// findRuntime looks up the IP in runtime and temporary storages, like
|
|
// /etc/hosts tables, DHCP leases, or blocklists.
|
|
func (clients *clientsContainer) findRuntime(ip net.IP, idStr string) (cj clientJSON, found bool) {
|
|
if ip == nil {
|
|
return cj, false
|
|
}
|
|
|
|
rc, ok := clients.FindRuntimeClient(idStr)
|
|
if !ok {
|
|
// It is still possible that the IP used to be in the runtime
|
|
// clients list, but then the server was reloaded. So, check
|
|
// the DNS server's blocked IP list.
|
|
//
|
|
// See https://github.com/AdguardTeam/AdGuardHome/issues/2428.
|
|
disallowed, rule := clients.dnsServer.IsBlockedIP(ip)
|
|
if rule == "" {
|
|
return clientJSON{}, false
|
|
}
|
|
|
|
cj = clientJSON{
|
|
IDs: []string{idStr},
|
|
Disallowed: disallowed,
|
|
DisallowedRule: rule,
|
|
WhoisInfo: &RuntimeClientWhoisInfo{},
|
|
}
|
|
|
|
return cj, true
|
|
}
|
|
|
|
cj = runtimeClientToJSON(idStr, rc)
|
|
cj.Disallowed, cj.DisallowedRule = clients.dnsServer.IsBlockedIP(ip)
|
|
|
|
return cj, true
|
|
}
|
|
|
|
// RegisterClientsHandlers registers HTTP handlers
|
|
func (clients *clientsContainer) registerWebHandlers() {
|
|
httpRegister(http.MethodGet, "/control/clients", clients.handleGetClients)
|
|
httpRegister(http.MethodPost, "/control/clients/add", clients.handleAddClient)
|
|
httpRegister(http.MethodPost, "/control/clients/delete", clients.handleDelClient)
|
|
httpRegister(http.MethodPost, "/control/clients/update", clients.handleUpdateClient)
|
|
httpRegister(http.MethodGet, "/control/clients/find", clients.handleFindClient)
|
|
}
|