ntfy/server/visitor.go

138 lines
3.6 KiB
Go
Raw Normal View History

2021-11-01 20:21:38 +01:00
package server
import (
2021-12-25 15:15:05 +01:00
"errors"
2022-12-02 21:37:48 +01:00
"heckel.io/ntfy/auth"
"net/netip"
2021-11-01 20:21:38 +01:00
"sync"
"time"
"golang.org/x/time/rate"
"heckel.io/ntfy/util"
2021-11-01 20:21:38 +01:00
)
const (
2021-12-24 00:03:04 +01:00
// visitorExpungeAfter defines how long a visitor is active before it is removed from memory. This number
// has to be very high to prevent e-mail abuse, but it doesn't really affect the other limits anyway, since
// they are replenished faster (typically).
visitorExpungeAfter = 24 * time.Hour
2021-11-01 20:21:38 +01:00
)
2021-12-25 15:15:05 +01:00
var (
errVisitorLimitReached = errors.New("limit reached")
)
2021-11-01 20:21:38 +01:00
// visitor represents an API user, and its associated rate.Limiter used for rate limiting
type visitor struct {
2021-12-19 04:02:36 +01:00
config *Config
2022-04-03 18:39:52 +02:00
messageCache *messageCache
ip netip.Addr
2022-12-02 21:37:48 +01:00
user *auth.User
2021-12-24 00:03:04 +01:00
requests *rate.Limiter
2022-01-04 00:55:08 +01:00
emails *rate.Limiter
2022-01-13 00:52:07 +01:00
subscriptions util.Limiter
2022-01-13 03:24:48 +01:00
bandwidth util.Limiter
2022-06-01 02:38:56 +02:00
firebase time.Time // Next allowed Firebase message
2021-11-01 20:21:38 +01:00
seen time.Time
mu sync.Mutex
}
2022-04-03 18:39:52 +02:00
type visitorStats struct {
AttachmentFileSizeLimit int64 `json:"attachmentFileSizeLimit"`
VisitorAttachmentBytesTotal int64 `json:"visitorAttachmentBytesTotal"`
VisitorAttachmentBytesUsed int64 `json:"visitorAttachmentBytesUsed"`
VisitorAttachmentBytesRemaining int64 `json:"visitorAttachmentBytesRemaining"`
}
2022-12-02 21:37:48 +01:00
func newVisitor(conf *Config, messageCache *messageCache, ip netip.Addr, user *auth.User) *visitor {
2021-11-01 20:21:38 +01:00
return &visitor{
2021-11-01 21:39:40 +01:00
config: conf,
2022-04-03 18:39:52 +02:00
messageCache: messageCache,
2021-12-24 15:01:29 +01:00
ip: ip,
2022-12-02 21:37:48 +01:00
user: user,
2021-12-24 00:03:04 +01:00
requests: rate.NewLimiter(rate.Every(conf.VisitorRequestLimitReplenish), conf.VisitorRequestLimitBurst),
2022-01-04 00:55:08 +01:00
emails: rate.NewLimiter(rate.Every(conf.VisitorEmailLimitReplenish), conf.VisitorEmailLimitBurst),
2022-01-13 00:52:07 +01:00
subscriptions: util.NewFixedLimiter(int64(conf.VisitorSubscriptionLimit)),
2022-01-13 03:24:48 +01:00
bandwidth: util.NewBytesLimiter(conf.VisitorAttachmentDailyBandwidthLimit, 24*time.Hour),
2022-06-01 02:38:56 +02:00
firebase: time.Unix(0, 0),
seen: time.Now(),
2021-11-01 20:21:38 +01:00
}
}
func (v *visitor) RequestAllowed() error {
2021-12-24 00:03:04 +01:00
if !v.requests.Allow() {
2021-12-25 15:15:05 +01:00
return errVisitorLimitReached
2021-12-24 00:03:04 +01:00
}
return nil
}
2022-06-01 02:38:56 +02:00
func (v *visitor) FirebaseAllowed() error {
v.mu.Lock()
defer v.mu.Unlock()
if time.Now().Before(v.firebase) {
return errVisitorLimitReached
}
return nil
}
func (v *visitor) FirebaseTemporarilyDeny() {
v.mu.Lock()
defer v.mu.Unlock()
2022-06-01 05:27:24 +02:00
v.firebase = time.Now().Add(v.config.FirebaseQuotaExceededPenaltyDuration)
2022-06-01 02:38:56 +02:00
}
2021-12-24 00:03:04 +01:00
func (v *visitor) EmailAllowed() error {
if !v.emails.Allow() {
2021-12-25 15:15:05 +01:00
return errVisitorLimitReached
2021-11-01 20:21:38 +01:00
}
return nil
}
2021-12-25 15:15:05 +01:00
func (v *visitor) SubscriptionAllowed() error {
2021-11-01 20:21:38 +01:00
v.mu.Lock()
defer v.mu.Unlock()
if err := v.subscriptions.Allow(1); err != nil {
2021-12-25 15:15:05 +01:00
return errVisitorLimitReached
2021-11-01 20:21:38 +01:00
}
return nil
}
func (v *visitor) RemoveSubscription() {
v.mu.Lock()
defer v.mu.Unlock()
v.subscriptions.Allow(-1)
2021-11-01 20:21:38 +01:00
}
func (v *visitor) Keepalive() {
v.mu.Lock()
defer v.mu.Unlock()
v.seen = time.Now()
}
2022-01-13 03:24:48 +01:00
func (v *visitor) BandwidthLimiter() util.Limiter {
return v.bandwidth
2022-01-13 00:52:07 +01:00
}
2021-11-01 20:21:38 +01:00
func (v *visitor) Stale() bool {
v.mu.Lock()
defer v.mu.Unlock()
return time.Since(v.seen) > visitorExpungeAfter
}
2022-04-03 18:39:52 +02:00
func (v *visitor) Stats() (*visitorStats, error) {
attachmentsBytesUsed, err := v.messageCache.AttachmentBytesUsed(v.ip.String())
2022-04-03 18:39:52 +02:00
if err != nil {
return nil, err
}
attachmentsBytesRemaining := v.config.VisitorAttachmentTotalSizeLimit - attachmentsBytesUsed
if attachmentsBytesRemaining < 0 {
attachmentsBytesRemaining = 0
}
return &visitorStats{
AttachmentFileSizeLimit: v.config.AttachmentFileSizeLimit,
VisitorAttachmentBytesTotal: v.config.VisitorAttachmentTotalSizeLimit,
VisitorAttachmentBytesUsed: attachmentsBytesUsed,
VisitorAttachmentBytesRemaining: attachmentsBytesRemaining,
}, nil
}