lordwelch/router7
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
router7/cmd/dhcp4d/dhcp4d.go

341 lines
7.4 KiB
Go
Raw Normal View History

add copyright notices
2018-06-28 13:39:48 +02:00
// Copyright 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Initial commit
2018-05-27 17:30:42 +02:00
// Binary dhcp4d hands out DHCPv4 leases to clients.
package main
import (
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
"bytes"
Initial commit
2018-05-27 17:30:42 +02:00
"encoding/json"
"flag"
dhcp4d: display MAC vendor of each lease’s HardwareAddr
2019-01-06 18:02:01 +01:00
"fmt"
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
"html/template"
Initial commit
2018-05-27 17:30:42 +02:00
"io/ioutil"
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
"net"
"net/http"
Initial commit
2018-05-27 17:30:42 +02:00
"os"
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
"os/signal"
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
"sort"
Initial commit
2018-05-27 17:30:42 +02:00
"syscall"
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
"time"
"github.com/gokrazy/gokrazy"
use renameio to write files atomically
2019-01-06 15:23:09 +01:00
"github.com/google/renameio"
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
"github.com/krolaw/dhcp4"
"github.com/krolaw/dhcp4/conn"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promauto"
"github.com/prometheus/client_golang/prometheus/promhttp"
Initial commit
2018-05-27 17:30:42 +02:00
update import paths
2018-07-09 08:54:04 +02:00
"github.com/rtr7/router7/internal/dhcp4d"
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
"github.com/rtr7/router7/internal/multilisten"
update import paths
2018-07-09 08:54:04 +02:00
"github.com/rtr7/router7/internal/notify"
dhcp4d: display MAC vendor of each lease’s HardwareAddr
2019-01-06 18:02:01 +01:00
"github.com/rtr7/router7/internal/oui"
update import paths
2018-07-09 08:54:04 +02:00
"github.com/rtr7/router7/internal/teelogger"
Initial commit
2018-05-27 17:30:42 +02:00
)
dhcp4d: introduce -interface flag
2019-07-20 10:50:30 +02:00
var iface = flag.String("interface", "lan0", "ethernet interface to listen for DHCPv4 requests on")
dhcp4d: implement loading leases files from persistent storage
2018-06-09 15:10:11 +02:00
var log = teelogger.NewConsole()
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
var nonExpiredLeases = promauto.NewGauge(prometheus.GaugeOpts{
Name: "non_expired_leases",
Help: "Number of non-expired DHCP leases",
})
func updateNonExpired(leases []*dhcp4d.Lease) {
now := time.Now()
nonExpired := 0
for _, l := range leases {
if l.Expired(now) {
continue
}
nonExpired++
}
nonExpiredLeases.Set(float64(nonExpired))
}
dhcp4d: display MAC vendor of each lease’s HardwareAddr
2019-01-06 18:02:01 +01:00
var ouiDB = oui.NewDB("/perm/dhcp4d/oui")
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
var leases []*dhcp4d.Lease
var (
timefmt = func(t time.Time) string {
return t.Format("2006-01-02 15:04")
}
leasesTmpl = template.Must(template.New("").Funcs(template.FuncMap{
"timefmt": timefmt,
"since": func(t time.Time) string {
dur := time.Since(t)
if dur.Hours() > 24 {
return timefmt(t)
}
return dur.Truncate(1 * time.Second).String()
},
}).Parse(`<!DOCTYPE html>
<head>
<meta charset="utf-8">
<title>DHCPv4 status</title>
<style type="text/css">
body {
margin-left: 1em;
}
td, th {
padding-left: 1em;
padding-right: 1em;
padding-bottom: .25em;
}
td:first-child, th:first-child {
padding-left: .25em;
}
td:last-child, th:last-child {
padding-right: .25em;
}
th {
padding-top: 1em;
text-align: left;
}
dhcp4d: add HostnameOverride field This can be used to permanently override a hostname, regardless of whether the lease is static or not. We use a separate field because we want devices to be able to change their hostname themselves, until we override it.
2019-08-30 09:06:21 +02:00
span.active, span.expired, span.static, span.hostname-override {
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
min-width: 5em;
display: inline-block;
text-align: center;
border: 1px solid grey;
border-radius: 5px;
}
span.active {
background-color: #00f000;
}
span.expired {
background-color: #f00000;
}
dhcp4d: add HostnameOverride field This can be used to permanently override a hostname, regardless of whether the lease is static or not. We use a separate field because we want devices to be able to change their hostname themselves, until we override it.
2019-08-30 09:06:21 +02:00
span.hostname-override {
min-width: 1em;
background-color: orange;
}
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
.ipaddr, .hwaddr {
font-family: monospace;
}
tr:nth-child(even) {
background: #eee;
}
</style>
</head>
<body>
{{ define "table" }}
<tr>
<th>IP address</th>
<th>Hostname</th>
<th>MAC address</th>
<th>Vendor</th>
<th>Expiry</th>
</tr>
{{ range $idx, $l := . }}
<tr>
<td class="ipaddr">{{$l.Addr}}</td>
dhcp4d: add HostnameOverride field This can be used to permanently override a hostname, regardless of whether the lease is static or not. We use a separate field because we want devices to be able to change their hostname themselves, until we override it.
2019-08-30 09:06:21 +02:00
<td>
{{$l.Hostname}}
{{ if (ne $l.HostnameOverride "") }}
<span class="hostname-override">!</span>
{{ end }}
</td>
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
<td class="hwaddr">{{$l.HardwareAddr}}</td>
<td>{{$l.Vendor}}</td>
<td title="{{ timefmt $l.Expiry }}">
{{ if $l.Expired }}
{{ since $l.Expiry }}
<span class="expired">expired</span>
{{ else }}
{{ if $l.Static }}
<span class="static">static</span>
{{ else }}
{{ timefmt $l.Expiry }}
<span class="active">active</span>
{{ end }}
{{ end }}
</td>
</tr>
{{ end }}
{{ end }}
<table cellpadding="0" cellspacing="0">
{{ template "table" .StaticLeases }}
{{ template "table" .DynamicLeases }}
</table>
</body>
</html>
`))
)
dhcp4d: implement loading leases files from persistent storage
2018-06-09 15:10:11 +02:00
func loadLeases(h *dhcp4d.Handler, fn string) error {
b, err := ioutil.ReadFile(fn)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
dhcp4d: implement permanent leases (no expiration)
2018-06-09 15:25:42 +02:00
if err := json.Unmarshal(b, &leases); err != nil {
dhcp4d: implement loading leases files from persistent storage
2018-06-09 15:10:11 +02:00
return err
}
h.SetLeases(leases)
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
updateNonExpired(leases)
dhcp4d: display MAC vendor of each lease’s HardwareAddr
2019-01-06 18:02:01 +01:00
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
dhcp4d: restrict lease details page to internal IPs
2019-02-19 07:50:39 +01:00
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
http.Error(w, "bad request", http.StatusBadRequest)
return
}
ip := net.ParseIP(host)
if xff := r.Header.Get("X-Forwarded-For"); ip.IsLoopback() && xff != "" {
ip = net.ParseIP(xff)
}
if !gokrazy.IsInPrivateNet(ip) {
http.Error(w, fmt.Sprintf("access from %v forbidden", ip), http.StatusForbidden)
return
}
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
type tmplLease struct {
dhcp4d.Lease
Vendor string
Expired bool
Static bool
}
static := make([]tmplLease, 0, len(leases))
dynamic := make([]tmplLease, 0, len(leases))
tl := func(l *dhcp4d.Lease) tmplLease {
return tmplLease{
Lease: *l,
Vendor: ouiDB.Lookup(l.HardwareAddr[:8]),
Expired: l.Expired(time.Now()),
Static: l.Expiry.IsZero(),
}
}
dhcp4d: display MAC vendor of each lease’s HardwareAddr
2019-01-06 18:02:01 +01:00
for _, l := range leases {
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
if l.Expiry.IsZero() {
static = append(static, tl(l))
} else {
dynamic = append(dynamic, tl(l))
}
}
sort.Slice(static, func(i, j int) bool {
return static[i].Num < static[j].Num
})
sort.Slice(dynamic, func(i, j int) bool {
return !dynamic[i].Expiry.Before(dynamic[j].Expiry)
})
if err := leasesTmpl.Execute(w, struct {
StaticLeases []tmplLease
DynamicLeases []tmplLease
}{
StaticLeases: static,
DynamicLeases: dynamic,
}); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
dhcp4d: display MAC vendor of each lease’s HardwareAddr
2019-01-06 18:02:01 +01:00
}
})
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
return nil
}
var httpListeners = multilisten.NewPool()
func updateListeners() error {
hosts, err := gokrazy.PrivateInterfaceAddrs()
if err != nil {
return err
}
if net1, err := multilisten.IPv6Net1("/perm"); err == nil {
hosts = append(hosts, net1)
}
httpListeners.ListenAndServe(hosts, func(host string) multilisten.Listener {
return &http.Server{Addr: net.JoinHostPort(host, "8067")}
})
dhcp4d: implement loading leases files from persistent storage
2018-06-09 15:10:11 +02:00
return nil
}
Initial commit
2018-05-27 17:30:42 +02:00
func logic() error {
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
http.Handle("/metrics", promhttp.Handler())
if err := updateListeners(); err != nil {
return err
}
go func() {
ch := make(chan os.Signal, 1)
signal.Notify(ch, syscall.SIGUSR1)
for range ch {
if err := updateListeners(); err != nil {
log.Printf("updateListeners: %v", err)
}
}
}()
Initial commit
2018-05-27 17:30:42 +02:00
if err := os.MkdirAll("/perm/dhcp4d", 0755); err != nil {
return err
}
errs := make(chan error)
dhcp4d: introduce -interface flag
2019-07-20 10:50:30 +02:00
ifc, err := net.InterfaceByName(*iface)
if err != nil {
return err
}
handler, err := dhcp4d.NewHandler("/perm", ifc, *iface, nil)
dnsd/dhcp4d: listen on configured address (not hard-coded)
2018-06-04 08:02:28 +02:00
if err != nil {
return err
}
dhcp4d: implement loading leases files from persistent storage
2018-06-09 15:10:11 +02:00
if err := loadLeases(handler, "/perm/dhcp4d/leases.json"); err != nil {
return err
}
dhcp4d: polish status page, actually update it upon changes
2019-07-20 10:53:41 +02:00
handler.Leases = func(newLeases []*dhcp4d.Lease, latest *dhcp4d.Lease) {
leases = newLeases
dhcp4d: log in leases callback
2018-06-24 11:56:39 +02:00
log.Printf("DHCPACK %+v", latest)
Initial commit
2018-05-27 17:30:42 +02:00
b, err := json.Marshal(leases)
if err != nil {
errs <- err
return
}
dhcp4d: indent leases.json for easier human editing
2019-07-20 10:49:53 +02:00
var out bytes.Buffer
if err := json.Indent(&out, b, "", "\t"); err == nil {
b = out.Bytes()
}
if err := renameio.WriteFile("/perm/dhcp4d/leases.json", out.Bytes(), 0644); err != nil {
Initial commit
2018-05-27 17:30:42 +02:00
errs <- err
}
dhcp4d: export number of non-expired DHCP leases
2018-10-23 08:49:29 +02:00
updateNonExpired(leases)
Initial commit
2018-05-27 17:30:42 +02:00
if err := notify.Process("/user/dnsd", syscall.SIGUSR1); err != nil {
log.Printf("notifying dnsd: %v", err)
}
}
dhcp4d: introduce -interface flag
2019-07-20 10:50:30 +02:00
conn, err := conn.NewUDP4BoundListener(*iface, ":67")
Initial commit
2018-05-27 17:30:42 +02:00
if err != nil {
return err
}
go func() {
errs <- dhcp4.Serve(conn, handler)
}()
return <-errs
}
func main() {
// TODO: drop privileges, run as separate uid?
flag.Parse()
if err := logic(); err != nil {
log.Fatal(err)
}
}
Reference in New Issue Copy Permalink