358 lines
10 KiB
Go
358 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/ecdh"
|
|
"crypto/rand"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"meshtastic_mqtt_server/mqtpp"
|
|
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
const (
|
|
botDefaultTopicPrefix = "msh/CN"
|
|
botDefaultPSK = "AQ=="
|
|
botDefaultNodeInfoBroadcastSeconds = int64(3600)
|
|
botMessageTypeChannel = "channel"
|
|
botMessageTypeDirect = "direct"
|
|
botMessageStatusPending = "pending"
|
|
botMessageStatusPublished = "published"
|
|
botMessageStatusFailed = "failed"
|
|
)
|
|
|
|
var errBotNodeAlreadyExists = errors.New("bot node already exists")
|
|
|
|
type botNodeInput struct {
|
|
NodeNum *int64
|
|
LongName string
|
|
ShortName string
|
|
Enabled bool
|
|
DefaultChannelID string
|
|
TopicPrefix string
|
|
PSK string
|
|
NodeInfoBroadcastEnabled bool
|
|
NodeInfoBroadcastIntervalSeconds int64
|
|
}
|
|
|
|
type botMessageListOptions struct {
|
|
listOptions
|
|
BotID uint64
|
|
MessageType string
|
|
ChannelID string
|
|
}
|
|
|
|
func (s *store) ListBotNodes(opts listOptions) ([]botNodeRecord, error) {
|
|
opts = normalizeListOptions(opts)
|
|
var rows []botNodeRecord
|
|
q := s.db.Model(&botNodeRecord{}).
|
|
Order("updated_at DESC").
|
|
Order("id DESC").
|
|
Limit(opts.Limit).
|
|
Offset(opts.Offset)
|
|
return rows, q.Find(&rows).Error
|
|
}
|
|
|
|
func (s *store) CountBotNodes(opts listOptions) (int64, error) {
|
|
var total int64
|
|
return total, s.db.Model(&botNodeRecord{}).Count(&total).Error
|
|
}
|
|
|
|
func (s *store) GetBotNode(id uint64) (*botNodeRecord, error) {
|
|
var row botNodeRecord
|
|
if err := s.db.Where("id = ?", id).Take(&row).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &row, nil
|
|
}
|
|
|
|
func (s *store) CreateBotNode(input botNodeInput) (*botNodeRecord, error) {
|
|
row, err := s.normalizedBotNodeRecord(input)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.ensureBotNodeUnique(0, row.NodeID, row.NodeNum); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.ensureBotNodeDoesNotConflictWithNodeInfo(row.NodeNum); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := populateBotNodeKeys(row); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.db.Create(row).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return row, nil
|
|
}
|
|
|
|
func (s *store) UpdateBotNode(id uint64, input botNodeInput) (*botNodeRecord, error) {
|
|
if id == 0 {
|
|
return nil, fmt.Errorf("bot node id is required")
|
|
}
|
|
if _, err := s.GetBotNode(id); err != nil {
|
|
return nil, err
|
|
}
|
|
row, err := s.normalizedBotNodeRecord(input)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.ensureBotNodeUnique(id, row.NodeID, row.NodeNum); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.ensureBotNodeDoesNotConflictWithNodeInfo(row.NodeNum); err != nil {
|
|
return nil, err
|
|
}
|
|
updates := map[string]any{
|
|
"node_id": row.NodeID,
|
|
"node_num": row.NodeNum,
|
|
"long_name": row.LongName,
|
|
"short_name": row.ShortName,
|
|
"enabled": row.Enabled,
|
|
"default_channel_id": row.DefaultChannelID,
|
|
"topic_prefix": row.TopicPrefix,
|
|
"psk": row.PSK,
|
|
"nodeinfo_broadcast_enabled": row.NodeInfoBroadcastEnabled,
|
|
"nodeinfo_broadcast_interval_seconds": row.NodeInfoBroadcastIntervalSeconds,
|
|
"updated_at": time.Now(),
|
|
}
|
|
if err := s.db.Model(&botNodeRecord{}).Where("id = ?", id).Updates(updates).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return s.GetBotNode(id)
|
|
}
|
|
|
|
func (s *store) DeleteBotNode(id uint64) error {
|
|
result := s.db.Where("id = ?", id).Delete(&botNodeRecord{})
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
if result.RowsAffected == 0 {
|
|
return gorm.ErrRecordNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *store) InsertBotMessage(row *botMessageRecord) error {
|
|
return s.db.Create(row).Error
|
|
}
|
|
|
|
func (s *store) UpdateBotMessageStatus(id uint64, status, errText string, publishedAt *time.Time) error {
|
|
updates := map[string]any{"status": status, "error": strings.TrimSpace(errText), "published_at": publishedAt}
|
|
result := s.db.Model(&botMessageRecord{}).Where("id = ?", id).Updates(updates)
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
if result.RowsAffected == 0 {
|
|
return gorm.ErrRecordNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *store) UpdateBotNodeInfoBroadcastAt(id uint64, t time.Time) error {
|
|
result := s.db.Model(&botNodeRecord{}).Where("id = ?", id).Updates(map[string]any{"last_nodeinfo_broadcast_at": &t, "updated_at": time.Now()})
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
if result.RowsAffected == 0 {
|
|
return gorm.ErrRecordNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *store) RegenerateBotNodeKeys(id uint64) (*botNodeRecord, error) {
|
|
if id == 0 {
|
|
return nil, fmt.Errorf("bot node id is required")
|
|
}
|
|
row, err := s.GetBotNode(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := populateBotNodeKeys(row); err != nil {
|
|
return nil, err
|
|
}
|
|
updates := map[string]any{"public_key": row.PublicKey, "private_key": row.PrivateKey, "updated_at": time.Now()}
|
|
if err := s.db.Model(&botNodeRecord{}).Where("id = ?", id).Updates(updates).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return s.GetBotNode(id)
|
|
}
|
|
|
|
func (s *store) ListBotMessages(opts botMessageListOptions) ([]botMessageRecord, error) {
|
|
opts.listOptions = normalizeListOptions(opts.listOptions)
|
|
var rows []botMessageRecord
|
|
q := applyBotMessageFilters(s.db.Model(&botMessageRecord{}), opts).
|
|
Order("created_at DESC").
|
|
Order("id DESC").
|
|
Limit(opts.Limit).
|
|
Offset(opts.Offset)
|
|
return rows, q.Find(&rows).Error
|
|
}
|
|
|
|
func (s *store) CountBotMessages(opts botMessageListOptions) (int64, error) {
|
|
var total int64
|
|
q := applyBotMessageFilters(s.db.Model(&botMessageRecord{}), opts)
|
|
return total, q.Count(&total).Error
|
|
}
|
|
|
|
func applyBotMessageFilters(q *gorm.DB, opts botMessageListOptions) *gorm.DB {
|
|
if opts.BotID != 0 {
|
|
q = q.Where("bot_id = ?", opts.BotID)
|
|
}
|
|
if opts.MessageType != "" {
|
|
q = q.Where("message_type = ?", opts.MessageType)
|
|
}
|
|
if opts.ChannelID != "" {
|
|
q = q.Where("channel_id = ?", opts.ChannelID)
|
|
}
|
|
if opts.Since != nil {
|
|
q = q.Where("created_at >= ?", *opts.Since)
|
|
}
|
|
if opts.Until != nil {
|
|
q = q.Where("created_at <= ?", *opts.Until)
|
|
}
|
|
return q
|
|
}
|
|
|
|
func (s *store) normalizedBotNodeRecord(input botNodeInput) (*botNodeRecord, error) {
|
|
longName := strings.TrimSpace(input.LongName)
|
|
shortName := strings.TrimSpace(input.ShortName)
|
|
channelID := strings.TrimSpace(input.DefaultChannelID)
|
|
psk := strings.TrimSpace(input.PSK)
|
|
if psk == "" {
|
|
psk = botDefaultPSK
|
|
}
|
|
if _, err := mqtpp.ExpandPSK(psk); err != nil {
|
|
return nil, err
|
|
}
|
|
topicPrefix := strings.Trim(strings.TrimSpace(input.TopicPrefix), "/")
|
|
if topicPrefix == "" {
|
|
topicPrefix = botDefaultTopicPrefix
|
|
}
|
|
if longName == "" {
|
|
return nil, fmt.Errorf("long name is required")
|
|
}
|
|
if !utf8.ValidString(longName) {
|
|
return nil, fmt.Errorf("long name must be valid utf-8")
|
|
}
|
|
if shortName == "" {
|
|
return nil, fmt.Errorf("short name is required")
|
|
}
|
|
if !utf8.ValidString(shortName) {
|
|
return nil, fmt.Errorf("short name must be valid utf-8")
|
|
}
|
|
if channelID == "" {
|
|
return nil, fmt.Errorf("default channel id is required")
|
|
}
|
|
interval := input.NodeInfoBroadcastIntervalSeconds
|
|
if interval <= 0 {
|
|
interval = botDefaultNodeInfoBroadcastSeconds
|
|
}
|
|
if interval < 60 {
|
|
return nil, fmt.Errorf("nodeinfo broadcast interval must be at least 60 seconds")
|
|
}
|
|
var nodeNum int64
|
|
if input.NodeNum == nil || *input.NodeNum == 0 {
|
|
generated, err := s.generateBotNodeNum()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nodeNum = generated
|
|
} else {
|
|
nodeNum = *input.NodeNum
|
|
}
|
|
if err := validateBotNodeNum(nodeNum); err != nil {
|
|
return nil, err
|
|
}
|
|
return &botNodeRecord{NodeID: mqtpp.NodeNumToID(uint32(nodeNum)), NodeNum: nodeNum, LongName: longName, ShortName: shortName, Enabled: input.Enabled, DefaultChannelID: channelID, TopicPrefix: topicPrefix, PSK: psk, NodeInfoBroadcastEnabled: input.NodeInfoBroadcastEnabled, NodeInfoBroadcastIntervalSeconds: interval}, nil
|
|
}
|
|
|
|
func populateBotNodeKeys(row *botNodeRecord) error {
|
|
privateKey, err := ecdh.X25519().GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
row.PrivateKey = base64.StdEncoding.EncodeToString(privateKey.Bytes())
|
|
row.PublicKey = base64.StdEncoding.EncodeToString(privateKey.PublicKey().Bytes())
|
|
return nil
|
|
}
|
|
|
|
func decodeBotPublicKey(row botNodeRecord) ([]byte, error) {
|
|
if strings.TrimSpace(row.PublicKey) == "" {
|
|
return nil, nil
|
|
}
|
|
key, err := base64.StdEncoding.DecodeString(row.PublicKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid bot public key: %w", err)
|
|
}
|
|
return key, nil
|
|
}
|
|
|
|
func validateBotNodeNum(nodeNum int64) error {
|
|
if nodeNum <= 0 || nodeNum >= int64(mqtpp.NodeNumBroadcast) {
|
|
return fmt.Errorf("node num must be between 1 and 4294967294")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *store) generateBotNodeNum() (int64, error) {
|
|
for i := 0; i < 32; i++ {
|
|
var buf [4]byte
|
|
if _, err := rand.Read(buf[:]); err != nil {
|
|
return 0, err
|
|
}
|
|
nodeNum := int64(binary.LittleEndian.Uint32(buf[:]) & 0x7fffffff)
|
|
if err := validateBotNodeNum(nodeNum); err != nil {
|
|
continue
|
|
}
|
|
if err := s.ensureBotNodeUnique(0, mqtpp.NodeNumToID(uint32(nodeNum)), nodeNum); err != nil {
|
|
if errors.Is(err, errBotNodeAlreadyExists) {
|
|
continue
|
|
}
|
|
return 0, err
|
|
}
|
|
if err := s.ensureBotNodeDoesNotConflictWithNodeInfo(nodeNum); err != nil {
|
|
if errors.Is(err, errBotNodeAlreadyExists) {
|
|
continue
|
|
}
|
|
return 0, err
|
|
}
|
|
return nodeNum, nil
|
|
}
|
|
return 0, fmt.Errorf("generate bot node num failed")
|
|
}
|
|
|
|
func (s *store) ensureBotNodeUnique(id uint64, nodeID string, nodeNum int64) error {
|
|
var existing botNodeRecord
|
|
q := s.db.Where("node_id = ? OR node_num = ?", nodeID, nodeNum)
|
|
if id != 0 {
|
|
q = q.Where("id <> ?", id)
|
|
}
|
|
err := q.Take(&existing).Error
|
|
if err == nil {
|
|
return errBotNodeAlreadyExists
|
|
}
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (s *store) ensureBotNodeDoesNotConflictWithNodeInfo(nodeNum int64) error {
|
|
var existing nodeInfoRecord
|
|
err := s.db.Where("node_num = ?", nodeNum).Take(&existing).Error
|
|
if err == nil {
|
|
return errBotNodeAlreadyExists
|
|
}
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|