260 lines
8.4 KiB
Go
260 lines
8.4 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"math/big"
|
|
"net"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/oschwald/maxminddb-golang"
|
|
)
|
|
|
|
// geoASN ist der optionale MaxMind-GeoLite2-ASN-Reader. Nil, wenn keine DB
|
|
// konfiguriert ist (KVER_GEOIP_ASN leer) oder das Öffnen fehlschlug -> die
|
|
// ASN-Auflösung degradiert dann still zu "" und die App läuft normal weiter.
|
|
var geoASN *maxminddb.Reader
|
|
|
|
// asnRecord deckt nur die beiden Felder der GeoLite2-ASN-DB ab, die wir brauchen.
|
|
type asnRecord struct {
|
|
Number uint `maxminddb:"autonomous_system_number"`
|
|
Org string `maxminddb:"autonomous_system_organization"`
|
|
}
|
|
|
|
// initGeoASN öffnet die ASN-Datenbank einmalig beim Start. Fehlt der Pfad oder
|
|
// die Datei, bleibt das Feature inaktiv (kein harter Fehler).
|
|
func initGeoASN() {
|
|
path := envOr("KVER_GEOIP_ASN", "")
|
|
if path == "" {
|
|
return
|
|
}
|
|
r, err := maxminddb.Open(path)
|
|
if err != nil {
|
|
log.Printf("GeoIP-ASN deaktiviert: %v", err)
|
|
return
|
|
}
|
|
geoASN = r
|
|
log.Printf("GeoIP-ASN aktiv: %s", path)
|
|
}
|
|
|
|
// closeGeoASN gibt den Reader frei (beim Shutdown).
|
|
func closeGeoASN() {
|
|
if geoASN != nil {
|
|
geoASN.Close()
|
|
}
|
|
}
|
|
|
|
// clientIP zieht die IP aus r.RemoteAddr (mit oder ohne Port). Nil, wenn nicht
|
|
// parsebar.
|
|
func clientIP(remoteAddr string) net.IP {
|
|
host := remoteAddr
|
|
if h, _, err := net.SplitHostPort(remoteAddr); err == nil {
|
|
host = h
|
|
}
|
|
return net.ParseIP(host)
|
|
}
|
|
|
|
// maskIP kürzt eine Client-IP auf das Netz: IPv4 auf /16 (erste 16 Bit), IPv6
|
|
// auf /32 (erste 32 Bit). /32 statt /48, weil Endkunden oft ein ganzes /48 oder
|
|
// /56 zugeteilt bekommen -> ein /48 könnte einen einzelnen Anschluss
|
|
// identifizieren; /32 landet auf Provider-Ebene und ist so grob wie das IPv4-
|
|
// /16. Liefert nil bei nil.
|
|
func maskIP(ip net.IP) net.IP {
|
|
if ip == nil {
|
|
return nil
|
|
}
|
|
if v4 := ip.To4(); v4 != nil {
|
|
return v4.Mask(net.CIDRMask(16, 32))
|
|
}
|
|
return ip.Mask(net.CIDRMask(32, 128))
|
|
}
|
|
|
|
// lookupASN löst das bereits anonymisierte Netz zum autonomen System auf. Die
|
|
// volle IP wird dafür bewusst NICHT verwendet -> wir kennen nur das maskierte
|
|
// Netz (/16 bei IPv4, /32 bei IPv6).
|
|
//
|
|
// Ein solches Netz gehört oft nicht einem einzigen AS: gerade im APNIC-Raum ist
|
|
// ein /16 in viele kleine Blöcke zerstückelt. Ein Lookup auf die Basisadresse
|
|
// liefert dann nur den (zufälligen) Inhaber von Offset 0. Stattdessen zählen wir
|
|
// per NetworksWithin alle ASNs im Netz und wählen das mit der größten
|
|
// Adress-Abdeckung; gibt es weitere, hängen wir "(n weitere Treffer)" an. So
|
|
// steht bei einem homogenen Netz schlicht der Betreiber, bei einem
|
|
// zersplitterten der dominante plus ein ehrlicher Unsicherheits-Hinweis.
|
|
//
|
|
// Liefert z.B. "AS3320 Deutsche Telekom AG", "AS8881 1&1 Versatel GmbH
|
|
// (2 weitere Treffer)" oder "" (keine DB/kein Treffer).
|
|
func lookupASN(ip net.IP) string {
|
|
if geoASN == nil || ip == nil {
|
|
return ""
|
|
}
|
|
// Das anonymisierte Netz rekonstruieren — gleiche Maske wie maskIP.
|
|
var network *net.IPNet
|
|
if v4 := ip.To4(); v4 != nil {
|
|
network = &net.IPNet{IP: v4, Mask: net.CIDRMask(16, 32)}
|
|
} else {
|
|
network = &net.IPNet{IP: ip, Mask: net.CIDRMask(32, 128)}
|
|
}
|
|
|
|
// Adress-Abdeckung je AS aufsummieren. big.Int, weil ein IPv6-Teilnetz im
|
|
// /32 bis zu 2^96 Adressen umfasst und int64 sprengen würde.
|
|
type cover struct {
|
|
org string
|
|
count *big.Int
|
|
}
|
|
covers := map[uint]*cover{}
|
|
nets := geoASN.NetworksWithin(network)
|
|
for nets.Next() {
|
|
var rec asnRecord
|
|
subnet, err := nets.Network(&rec)
|
|
if err != nil || rec.Number == 0 {
|
|
continue
|
|
}
|
|
ones, bits := subnet.Mask.Size()
|
|
size := new(big.Int).Lsh(big.NewInt(1), uint(bits-ones))
|
|
c := covers[rec.Number]
|
|
if c == nil {
|
|
c = &cover{org: rec.Org, count: new(big.Int)}
|
|
covers[rec.Number] = c
|
|
}
|
|
c.count.Add(c.count, size)
|
|
}
|
|
if len(covers) == 0 {
|
|
return ""
|
|
}
|
|
|
|
// AS mit der größten Abdeckung wählen. Bei Gleichstand das kleinere ASN,
|
|
// damit das Ergebnis bei zufälliger Map-Reihenfolge stabil bleibt.
|
|
var bestNum uint
|
|
var best *cover
|
|
for num, c := range covers {
|
|
if best == nil {
|
|
best, bestNum = c, num
|
|
continue
|
|
}
|
|
if cmp := c.count.Cmp(best.count); cmp > 0 || (cmp == 0 && num < bestNum) {
|
|
best, bestNum = c, num
|
|
}
|
|
}
|
|
|
|
label := fmt.Sprintf("AS%d", bestNum)
|
|
if best.org != "" {
|
|
label += " " + best.org
|
|
}
|
|
if extra := len(covers) - 1; extra > 0 {
|
|
label += fmt.Sprintf(" (%d weitere Treffer)", extra)
|
|
}
|
|
return label
|
|
}
|
|
|
|
// trackImpression zählt einen Seitenaufruf pro (Tag, anonymisiertes Netz, Pfad)
|
|
// und vermerkt das autonome System. Die IP wird zuerst maskiert; sowohl die
|
|
// Speicherung als auch die ASN-Auflösung arbeiten nur auf dem anonymisierten
|
|
// Netz. Gezielt nur auf den HTML-Seiten-Routen, nicht auf API oder Assets.
|
|
//
|
|
// Die Erfassung läuft asynchron: der Seitenaufruf darf nicht auf den DB-Schreib
|
|
// warten (SQLite serialisiert Schreiber, synchronous=FULL macht pro Commit ein
|
|
// fsync). r ist nach Rückkehr des Handlers nicht mehr sicher nutzbar -> wir
|
|
// kopieren die zwei Werte vorher heraus.
|
|
func trackImpression(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
remote, path := r.RemoteAddr, r.URL.Path
|
|
go func() {
|
|
netw := maskIP(clientIP(remote))
|
|
anon := ""
|
|
if netw != nil {
|
|
anon = netw.String()
|
|
}
|
|
recordImpression(path, anon, lookupASN(netw))
|
|
}()
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
// recordImpression erhöht den Zähler für (heute, Netz, Pfad) per Upsert. Das asn
|
|
// wird nur beim ersten Insert gesetzt (pro Netz stabil). Fehler werden bewusst
|
|
// geschluckt: ein verlorener Zählwert darf nie eine Seite stören.
|
|
func recordImpression(path, anonIP, asn string) {
|
|
if anonIP == "" {
|
|
return
|
|
}
|
|
day := time.Now().UTC().Format("2006-01-02")
|
|
db.Exec(
|
|
`INSERT INTO impression (day, anon_ip, path, asn, hits) VALUES (?, ?, ?, ?, 1)
|
|
ON CONFLICT(day, anon_ip, path) DO UPDATE SET hits = hits + 1`,
|
|
day, anonIP, path, asn,
|
|
)
|
|
}
|
|
|
|
// handleStatsDetail liefert die Kennzahlen für die Statistik-Seite. Anders als
|
|
// /stats (Tagline, bei jedem Aufruf) darf das hier ruhig mehrere Aggregate
|
|
// rechnen. Öffentlich, kein Auth.
|
|
func handleStatsDetail(w http.ResponseWriter, r *http.Request) {
|
|
var users, entries, toplevel, votesLeft, votesRight int64
|
|
db.QueryRow(`SELECT COUNT(*) FROM user`).Scan(&users)
|
|
db.QueryRow(`SELECT COUNT(*) FROM entry WHERE deleted = 0`).Scan(&entries)
|
|
db.QueryRow(`SELECT COUNT(*) FROM entry WHERE deleted = 0 AND reply_to = 0`).Scan(&toplevel)
|
|
db.QueryRow(`SELECT COUNT(*) FROM vote WHERE mode = 'left'`).Scan(&votesLeft)
|
|
db.QueryRow(`SELECT COUNT(*) FROM vote WHERE mode = 'right'`).Scan(&votesRight)
|
|
|
|
var imprTotal, visitorsTotal int64
|
|
db.QueryRow(`SELECT COALESCE(SUM(hits), 0), COUNT(DISTINCT anon_ip) FROM impression`).
|
|
Scan(&imprTotal, &visitorsTotal)
|
|
|
|
// Tägliche Impressions + grobe Unique-Netze, jüngste 30 Tage zuerst. Das
|
|
// Frontend dreht für die Achse auf aufsteigend.
|
|
daily := []map[string]any{}
|
|
if rows, err := db.Query(
|
|
`SELECT day, SUM(hits), COUNT(DISTINCT anon_ip)
|
|
FROM impression
|
|
GROUP BY day
|
|
ORDER BY day DESC
|
|
LIMIT 30`); err == nil {
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var day string
|
|
var hits, visitors int64
|
|
rows.Scan(&day, &hits, &visitors)
|
|
daily = append(daily, map[string]any{"day": day, "impressions": hits, "visitors": visitors})
|
|
}
|
|
}
|
|
|
|
// Netze nach Betreiber (autonomes System). Leere asn ('') -> "(unbekannt)".
|
|
topASNs := []map[string]any{}
|
|
if rows, err := db.Query(
|
|
`SELECT CASE WHEN asn = '' THEN '(unbekannt)' ELSE asn END AS a,
|
|
SUM(hits) AS h,
|
|
COUNT(DISTINCT anon_ip)
|
|
FROM impression
|
|
GROUP BY a
|
|
ORDER BY h DESC
|
|
LIMIT 10`); err == nil {
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var asn string
|
|
var hits, networks int64
|
|
rows.Scan(&asn, &hits, &networks)
|
|
topASNs = append(topASNs, map[string]any{"asn": asn, "hits": hits, "networks": networks})
|
|
}
|
|
}
|
|
|
|
writeJSON(w, http.StatusOK, map[string]any{
|
|
"users": users,
|
|
"entries": entries,
|
|
"toplevel": toplevel,
|
|
"replies": entries - toplevel,
|
|
"votes": map[string]any{"left": votesLeft, "right": votesRight},
|
|
"impressions_total": imprTotal,
|
|
"visitors_total": visitorsTotal,
|
|
"daily": daily,
|
|
"top_asns": topASNs,
|
|
})
|
|
}
|
|
|
|
// serveIndex liefert die Startseite. Eigene Route (statt FileServer-Catch-All),
|
|
// damit trackImpression nur echte Seitenaufrufe von "/" zählt und nicht jedes
|
|
// Asset.
|
|
func serveIndex(w http.ResponseWriter, r *http.Request) {
|
|
http.ServeFile(w, r, "web/index.html")
|
|
}
|