From 07a5c81fb26f0474da291b5921bfd741986d1160 Mon Sep 17 00:00:00 2001 From: junleea <354425203@qq.com> Date: Sat, 2 May 2026 14:45:51 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0DNS=E6=9C=8D=E5=8A=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dao/db.go | 13 + dao/dns.go | 289 +++++++++++++++ go.mod | 17 +- go.sum | 16 + handler/cid.go | 5 +- handler/dns.go | 406 +++++++++++++++++++++ main.go | 8 +- proto/dns.go | 200 ++++++++++ service/dnsService.go | 786 ++++++++++++++++++++++++++++++++++++++++ service/shellService.go | 1 - 10 files changed, 1727 insertions(+), 14 deletions(-) create mode 100644 dao/dns.go create mode 100644 handler/dns.go create mode 100644 proto/dns.go create mode 100644 service/dnsService.go diff --git a/dao/db.go b/dao/db.go index 93a2f52..7077b9d 100644 --- a/dao/db.go +++ b/dao/db.go @@ -122,6 +122,19 @@ func Init() error { log.Println("sqlrunhistory table:", err) } + err = db.AutoMigrate(&proto.DNSServer{}) + if err != nil { + log.Println("dnsserver table:", err) + } + err = db.AutoMigrate(&proto.DNSZone{}) + if err != nil { + log.Println("dnszone table:", err) + } + err = db.AutoMigrate(&proto.DNSRecord{}) + if err != nil { + log.Println("dnsrecord table:", err) + } + DB = db return err } diff --git a/dao/dns.go b/dao/dns.go new file mode 100644 index 0000000..ae18bbe --- /dev/null +++ b/dao/dns.go @@ -0,0 +1,289 @@ +package dao + +import ( + "videoplayer/proto" + + "gorm.io/gorm" +) + +// ==================== DNSServer 相关操作 ==================== + +func CreateDNSServer(server proto.DNSServer) (uint, error) { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Create(&server) + if res.Error != nil { + return 0, res.Error + } + return server.ID, nil +} + +func FindDNSServerByID(id uint) (proto.DNSServer, error) { + var server proto.DNSServer + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("id = ?", id).First(&server) + if res.Error != nil { + return proto.DNSServer{}, res.Error + } + return server, nil +} + +func FindDNSServerByUserID(userID uint) ([]proto.DNSServer, error) { + var servers []proto.DNSServer + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("user_id = ?", userID).Find(&servers) + if res.Error != nil { + return nil, res.Error + } + return servers, nil +} + +func FindAllDNSServer() ([]proto.DNSServer, error) { + var servers []proto.DNSServer + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Find(&servers) + if res.Error != nil { + return nil, res.Error + } + return servers, nil +} + +func UpdateDNSServer(id uint, server *proto.DNSServer) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Model(&proto.DNSServer{}).Where("id = ?", id).Updates(server) + return res.Error +} + +func DeleteDNSServerByID(id uint) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("id = ?", id).Delete(&proto.DNSServer{}) + return res.Error +} + +func DeleteDNSServerByUserID(userID uint) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("user_id = ?", userID).Delete(&proto.DNSServer{}) + return res.Error +} + +// ==================== DNSZone 相关操作 ==================== + +func CreateDNSZone(zone proto.DNSZone) (uint, error) { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Create(&zone) + if res.Error != nil { + return 0, res.Error + } + return zone.ID, nil +} + +func FindDNSZoneByID(id uint) (proto.DNSZone, error) { + var zone proto.DNSZone + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("id = ?", id).First(&zone) + if res.Error != nil { + return proto.DNSZone{}, res.Error + } + return zone, nil +} + +func FindDNSZoneByServerID(serverID uint) ([]proto.DNSZone, error) { + var zones []proto.DNSZone + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("server_id = ?", serverID).Find(&zones) + if res.Error != nil { + return nil, res.Error + } + return zones, nil +} + +func FindAllDNSZone() ([]proto.DNSZone, error) { + var zones []proto.DNSZone + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Find(&zones) + if res.Error != nil { + return nil, res.Error + } + return zones, nil +} + +func UpdateDNSZone(id uint, zone *proto.DNSZone) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Model(&proto.DNSZone{}).Where("id = ?", id).Updates(zone) + return res.Error +} + +func DeleteDNSZoneByID(id uint) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("id = ?", id).Delete(&proto.DNSZone{}) + return res.Error +} + +func DeleteDNSZoneByServerID(serverID uint) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("server_id = ?", serverID).Delete(&proto.DNSZone{}) + return res.Error +} + +// ==================== DNSRecord 相关操作 ==================== + +func CreateDNSRecord(record proto.DNSRecord) (uint, error) { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Create(&record) + if res.Error != nil { + return 0, res.Error + } + return record.ID, nil +} + +func FindDNSRecordByID(id uint) (proto.DNSRecord, error) { + var record proto.DNSRecord + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("id = ?", id).First(&record) + if res.Error != nil { + return proto.DNSRecord{}, res.Error + } + return record, nil +} + +func FindDNSRecordByZoneID(zoneID uint) ([]proto.DNSRecord, error) { + var records []proto.DNSRecord + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("zone_id = ?", zoneID).Find(&records) + if res.Error != nil { + return nil, res.Error + } + return records, nil +} + +func FindAllDNSRecord() ([]proto.DNSRecord, error) { + var records []proto.DNSRecord + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Find(&records) + if res.Error != nil { + return nil, res.Error + } + return records, nil +} + +func UpdateDNSRecord(id uint, record *proto.DNSRecord) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Model(&proto.DNSRecord{}).Where("id = ?", id).Updates(record) + return res.Error +} + +func DeleteDNSRecordByID(id uint) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("id = ?", id).Delete(&proto.DNSRecord{}) + return res.Error +} + +func DeleteDNSRecordByZoneID(zoneID uint) error { + var db2 *gorm.DB + if proto.Config.SERVER_SQL_LOG { + db2 = DB.Debug() + } else { + db2 = DB + } + res := db2.Where("zone_id = ?", zoneID).Delete(&proto.DNSRecord{}) + return res.Error +} diff --git a/go.mod b/go.mod index 9403142..0a9caf7 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module videoplayer -go 1.21 +go 1.24.0 require ( github.com/gin-gonic/gin v1.10.0 @@ -8,9 +8,11 @@ require ( github.com/golang-jwt/jwt v3.2.2+incompatible github.com/google/uuid v1.6.0 github.com/gorilla/websocket v1.5.3 + github.com/miekg/dns v1.1.72 github.com/robfig/cron/v3 v3.0.1 gorm.io/driver/mysql v1.5.6 gorm.io/driver/postgres v1.5.9 + gorm.io/driver/sqlite v1.6.0 gorm.io/gorm v1.30.0 ) @@ -47,12 +49,13 @@ require ( github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/ugorji/go/codec v1.2.12 // indirect golang.org/x/arch v0.8.0 // indirect - golang.org/x/crypto v0.23.0 // indirect - golang.org/x/net v0.25.0 // indirect - golang.org/x/sync v0.9.0 // indirect - golang.org/x/sys v0.20.0 // indirect - golang.org/x/text v0.20.0 // indirect + golang.org/x/crypto v0.46.0 // indirect + golang.org/x/mod v0.31.0 // indirect + golang.org/x/net v0.48.0 // indirect + golang.org/x/sync v0.19.0 // indirect + golang.org/x/sys v0.39.0 // indirect + golang.org/x/text v0.32.0 // indirect + golang.org/x/tools v0.40.0 // indirect google.golang.org/protobuf v1.34.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - gorm.io/driver/sqlite v1.6.0 // indirect ) diff --git a/go.sum b/go.sum index 831f1c2..4a4bfed 100644 --- a/go.sum +++ b/go.sum @@ -73,6 +73,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU= github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= +github.com/miekg/dns v1.1.72 h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI= +github.com/miekg/dns v1.1.72/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= @@ -113,20 +115,34 @@ golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc= golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= +golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU= +golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0= +golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI= +golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg= golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac= golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= +golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU= +golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY= golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ= golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4= +golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk= +golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= +golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU= +golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY= +golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA= +golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg= diff --git a/handler/cid.go b/handler/cid.go index e21a8e0..9e0cc84 100644 --- a/handler/cid.go +++ b/handler/cid.go @@ -1,7 +1,6 @@ package handler import ( - "bytes" "encoding/json" "fmt" "github.com/gin-gonic/gin" @@ -125,7 +124,7 @@ func RunCID(c *gin.Context) { c.JSON(200, gin.H{"error": "CID not found", "code": proto.OperationFailed, "message": "failed"}) return } else { - cidTaskQueue <- CIDTask{ + cidTaskQueue <- CIDTask{ Name: cid.Name, Url: cid.Url, Script: cid.Script, @@ -268,7 +267,7 @@ func CIDCallback(c *gin.Context) { return } if res.ID != 0 { - cidTaskQueue <- CIDTask{ + cidTaskQueue <- CIDTask{ Name: res.Name, Url: res.Url, Script: res.Script, diff --git a/handler/dns.go b/handler/dns.go new file mode 100644 index 0000000..4df80b0 --- /dev/null +++ b/handler/dns.go @@ -0,0 +1,406 @@ +package handler + +import ( + "net/http" + "videoplayer/proto" + "videoplayer/service" + + "github.com/gin-gonic/gin" +) + +func SetDNSGroup(router *gin.Engine) { + dns := router.Group("/dns") + + dns.POST("/server/create", CreateDNSServerHandler) + dns.POST("/server/get", GetDNSServerHandler) + dns.POST("/server/update", UpdateDNSServerHandler) + dns.POST("/server/delete", DeleteDNSServerHandler) + dns.POST("/server/start", StartDNSServerHandler) + dns.POST("/server/stop", StopDNSServerHandler) + dns.POST("/server/restart", RestartDNSServerHandler) + dns.POST("/server/status", GetDNSServerStatusHandler) + + dns.POST("/zone/create", CreateDNSZoneHandler) + dns.POST("/zone/get", GetDNSZoneHandler) + dns.POST("/zone/update", UpdateDNSZoneHandler) + dns.POST("/zone/delete", DeleteDNSZoneHandler) + + dns.POST("/record/create", CreateDNSRecordHandler) + dns.POST("/record/get", GetDNSRecordHandler) + dns.POST("/record/update", UpdateDNSRecordHandler) + dns.POST("/record/delete", DeleteDNSRecordHandler) +} + +// ==================== DNSServer 相关 Handler ==================== + +func CreateDNSServerHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := uint(id.(float64)) + + var req proto.CreateDNSServerReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + server, err := service.CreateDNSServer(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "创建DNS服务器失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "创建DNS服务器成功" + resp.Data = server + } + } + c.JSON(http.StatusOK, resp) +} + +func GetDNSServerHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := uint(id.(float64)) + + var req proto.GetDNSServerReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + servers, err := service.GetDNSServerList(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "获取DNS服务器失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "获取DNS服务器成功" + resp.Data = servers + } + } + c.JSON(http.StatusOK, resp) +} + +func UpdateDNSServerHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.UpdateDNSServerReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + server, err := service.UpdateDNSServer(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "更新DNS服务器失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "更新DNS服务器成功" + resp.Data = server + } + } + c.JSON(http.StatusOK, resp) +} + +func DeleteDNSServerHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.DeleteDNSServerReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + err := service.DeleteDNSServer(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "删除DNS服务器失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "删除DNS服务器成功" + } + } + c.JSON(http.StatusOK, resp) +} + +// ==================== DNSZone 相关 Handler ==================== + +func CreateDNSZoneHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := uint(id.(float64)) + + var req proto.CreateDNSZoneReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + zone, err := service.CreateDNSZone(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "创建DNS区域失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "创建DNS区域成功" + resp.Data = zone + } + } + c.JSON(http.StatusOK, resp) +} + +func GetDNSZoneHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := uint(id.(float64)) + + var req proto.GetDNSZoneReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + zones, err := service.GetDNSZoneList(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "获取DNS区域失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "获取DNS区域成功" + resp.Data = zones + } + } + c.JSON(http.StatusOK, resp) +} + +func UpdateDNSZoneHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.UpdateDNSZoneReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + zone, err := service.UpdateDNSZone(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "更新DNS区域失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "更新DNS区域成功" + resp.Data = zone + } + } + c.JSON(http.StatusOK, resp) +} + +func DeleteDNSZoneHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.DeleteDNSZoneReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + err := service.DeleteDNSZone(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "删除DNS区域失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "删除DNS区域成功" + } + } + c.JSON(http.StatusOK, resp) +} + +// ==================== DNSRecord 相关 Handler ==================== + +func CreateDNSRecordHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := uint(id.(float64)) + + var req proto.CreateDNSRecordReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + record, err := service.CreateDNSRecord(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "创建DNS记录失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "创建DNS记录成功" + resp.Data = record + } + } + c.JSON(http.StatusOK, resp) +} + +func GetDNSRecordHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := uint(id.(float64)) + + var req proto.GetDNSRecordReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + records, err := service.GetDNSRecordList(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "获取DNS记录失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "获取DNS记录成功" + resp.Data = records + } + } + c.JSON(http.StatusOK, resp) +} + +func UpdateDNSRecordHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.UpdateDNSRecordReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + record, err := service.UpdateDNSRecord(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "更新DNS记录失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "更新DNS记录成功" + resp.Data = record + } + } + c.JSON(http.StatusOK, resp) +} + +func DeleteDNSRecordHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.DeleteDNSRecordReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + err := service.DeleteDNSRecord(&req, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "删除DNS记录失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "删除DNS记录成功" + } + } + c.JSON(http.StatusOK, resp) +} + +// 启动DNS服务器 +func StartDNSServerHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.StartDNSServerReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + instance, err := service.StartDNSServer(req.ServerID, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "启动DNS服务器失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "启动DNS服务器成功" + resp.Data = instance + } + } + c.JSON(http.StatusOK, resp) +} + +// 停止DNS服务器 +func StopDNSServerHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.StopDNSServerReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + err := service.StopDNSServer(req.ServerID, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "停止DNS服务器失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "停止DNS服务器成功" + } + } + c.JSON(http.StatusOK, resp) +} + +// 重启DNS服务器 +func RestartDNSServerHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.RestartDNSServerReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + instance, err := service.RestartDNSServer(req.ServerID, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "重启DNS服务器失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "重启DNS服务器成功" + resp.Data = instance + } + } + c.JSON(http.StatusOK, resp) +} + +// 获取DNS服务器状态 +func GetDNSServerStatusHandler(c *gin.Context) { + id, _ := c.Get("id") + userID := int(id.(float64)) + + var req proto.GetDNSServerStatusReq + var resp proto.GeneralResp + if err := c.ShouldBind(&req); err != nil { + resp.Code = proto.ParameterError + resp.Message = "请求参数解析错误" + } else { + status, err := service.GetDNSServerStatus(req.ServerID, userID) + if err != nil { + resp.Code = proto.ErrorCode + resp.Message = "获取DNS服务器状态失败: " + err.Error() + } else { + resp.Code = proto.SuccessCode + resp.Message = "获取DNS服务器状态成功" + resp.Data = status + } + } + c.JSON(http.StatusOK, resp) +} diff --git a/main.go b/main.go index 177110f..86cc5d9 100644 --- a/main.go +++ b/main.go @@ -3,9 +3,6 @@ package main import ( "encoding/json" "fmt" - "github.com/gin-gonic/gin" - "github.com/golang-jwt/jwt" - "github.com/robfig/cron/v3" "io" "log" "net/http" @@ -17,6 +14,10 @@ import ( "videoplayer/proto" "videoplayer/service" "videoplayer/worker" + + "github.com/gin-gonic/gin" + "github.com/golang-jwt/jwt" + "github.com/robfig/cron/v3" ) func main() { @@ -49,6 +50,7 @@ func main() { handler.SetUpFileGroup(r) // File handler.SetUpShellGroup(r) // Shell handler.SetDBManageGroup(r) // DBM + handler.SetDNSGroup(r) // DNS defer dao.Close() defer worker.CloseRedis() //定时任务 diff --git a/proto/dns.go b/proto/dns.go new file mode 100644 index 0000000..9aa93d3 --- /dev/null +++ b/proto/dns.go @@ -0,0 +1,200 @@ +package proto + +import ( + "gorm.io/gorm" +) + +const ( + DNS_STATUS_STOPPED = 0 // DNS服务器状态：已停止 + DNS_STATUS_RUNNING = 1 // DNS服务器状态：运行中 + DNS_STATUS_ERROR = 2 // DNS服务器状态：错误 + + RECORD_TYPE_A = 1 // A记录 + RECORD_TYPE_AAAA = 28 // AAAA记录 + RECORD_TYPE_CNAME = 5 // CNAME记录 + RECORD_TYPE_MX = 15 // MX记录 + RECORD_TYPE_NS = 2 // NS记录 + RECORD_TYPE_SOA = 6 // SOA记录 + RECORD_TYPE_TXT = 16 // TXT记录 + RECORD_TYPE_SRV = 33 // SRV记录 +) + +type DNSServer struct { + gorm.Model + UserID uint `gorm:"column:user_id;index" json:"user_id" form:"user_id"` // 用户ID + Name string `gorm:"column:name;type:varchar(255)" json:"name" form:"name"` // DNS服务器名称 + Port uint `gorm:"column:port;default:53" json:"port" form:"port"` // 监听端口，默认53 + ListenIP string `gorm:"column:listen_ip;type:varchar(255)" json:"listen_ip" form:"listen_ip"` // 监听IP，默认0.0.0.0 + UpstreamDNS string `gorm:"column:upstream_dns;type:varchar(255)" json:"upstream_dns" form:"upstream_dns"` // 上游DNS服务器，多个用逗号分隔 + EnableRecursion bool `gorm:"column:enable_recursion;default:true" json:"enable_recursion" form:"enable_recursion"` // 是否启用递归查询 + Status uint `gorm:"column:status;default:0" json:"status" form:"status"` // 状态：0停止，1运行中，2错误 + Description string `gorm:"column:description;type:text" json:"description" form:"description"` // 描述 + Zones []DNSZone `gorm:"foreignKey:ServerID" json:"zones,omitempty"` // 关联的Zone +} + +type DNSZone struct { + gorm.Model + ServerID uint `gorm:"column:server_id;index" json:"server_id" form:"server_id"` // 所属DNS服务器ID + Domain string `gorm:"column:domain;type:varchar(255);index" json:"domain" form:"domain"` // 域名，如 example.com + SOA_MName string `gorm:"column:soa_mname;type:varchar(255)" json:"soa_mname" form:"soa_mname"` // SOA记录的主域名服务器 + SOA_RName string `gorm:"column:soa_rname;type:varchar(255)" json:"soa_rname" form:"soa_rname"` // SOA记录的管理员邮箱 + SOA_Serial uint `gorm:"column:soa_serial;default:1" json:"soa_serial" form:"soa_serial"` // SOA记录的序列号 + SOA_Refresh uint `gorm:"column:soa_refresh;default:86400" json:"soa_refresh" form:"soa_refresh"` // SOA记录的刷新时间（秒） + SOA_Retry uint `gorm:"column:soa_retry;default:7200" json:"soa_retry" form:"soa_retry"` // SOA记录的重试时间（秒） + SOA_Expire uint `gorm:"column:soa_expire;default:3600000" json:"soa_expire" form:"soa_expire"` // SOA记录的过期时间（秒） + SOA_Minimum uint `gorm:"column:soa_minimum;default:3600" json:"soa_minimum" form:"soa_minimum"` // SOA记录的最小TTL（秒） + TTL uint `gorm:"column:ttl;default:3600" json:"ttl" form:"ttl"` // 默认TTL（秒） + Description string `gorm:"column:description;type:text" json:"description" form:"description"` // 描述 + Server DNSServer `gorm:"foreignKey:ServerID" json:"server,omitempty"` // 关联的DNS服务器 + Records []DNSRecord `gorm:"foreignKey:ZoneID" json:"records,omitempty"` // 关联的记录 +} + +type DNSRecord struct { + gorm.Model + ZoneID uint `gorm:"column:zone_id;index" json:"zone_id" form:"zone_id"` // 所属Zone ID + Name string `gorm:"column:name;type:varchar(255);index" json:"name" form:"name"` // 记录名称，如 www 或 @ + Type uint `gorm:"column:type;index" json:"type" form:"type"` // 记录类型：1=A, 28=AAAA, 5=CNAME, 15=MX等 + Value string `gorm:"column:value;type:text" json:"value" form:"value"` // 记录值 + TTL uint `gorm:"column:ttl;default:3600" json:"ttl" form:"ttl"` // TTL（秒），如果为0则使用Zone的默认TTL + Priority uint `gorm:"column:priority;default:0" json:"priority" form:"priority"` // 优先级（用于MX、SRV等记录） + Weight uint `gorm:"column:weight;default:0" json:"weight" form:"weight"` // 权重（用于SRV记录） + Port uint `gorm:"column:port;default:0" json:"port" form:"port"` // 端口（用于SRV记录） + Target string `gorm:"column:target;type:varchar(255)" json:"target" form:"target"` // 目标（用于SRV记录） + Zone DNSZone `gorm:"foreignKey:ZoneID" json:"zone,omitempty"` // 关联的Zone +} + +// DNSServer 创建请求 +type CreateDNSServerReq struct { + Name string `json:"name" form:"name"` // DNS服务器名称 + Port uint `json:"port" form:"port"` // 监听端口，默认53 + ListenIP string `json:"listen_ip" form:"listen_ip"` // 监听IP，默认0.0.0.0 + UpstreamDNS string `json:"upstream_dns" form:"upstream_dns"` // 上游DNS服务器，多个用逗号分隔 + EnableRecursion bool `json:"enable_recursion" form:"enable_recursion"` // 是否启用递归查询 + Description string `json:"description" form:"description"` // 描述 +} + +// DNSServer 更新请求 +type UpdateDNSServerReq struct { + ServerID uint `json:"server_id" form:"server_id"` // DNS服务器ID + Name string `json:"name" form:"name"` // DNS服务器名称 + Port uint `json:"port" form:"port"` // 监听端口 + ListenIP string `json:"listen_ip" form:"listen_ip"` // 监听IP + UpstreamDNS string `json:"upstream_dns" form:"upstream_dns"` // 上游DNS服务器 + EnableRecursion bool `json:"enable_recursion" form:"enable_recursion"` // 是否启用递归查询 + Status uint `json:"status" form:"status"` // 状态：0停止，1运行中，2错误 + Description string `json:"description" form:"description"` // 描述 +} + +// DNSServer 获取请求 +type GetDNSServerReq struct { + ServerID uint `json:"server_id" form:"server_id"` // DNS服务器ID，0表示获取全部 + GetType int `json:"get_type" form:"get_type"` // 获取类型：0获取自己的，1获取全部（管理员） +} + +// DNSServer 删除请求 +type DeleteDNSServerReq struct { + ServerID uint `json:"server_id" form:"server_id"` // DNS服务器ID + DelType uint `json:"del_type" form:"del_type"` // 删除类型：0删除单条，1删除所有 +} + +// DNSZone 创建请求 +type CreateDNSZoneReq struct { + ServerID uint `json:"server_id" form:"server_id"` // 所属DNS服务器ID + Domain string `json:"domain" form:"domain"` // 域名，如 example.com + SOA_MName string `json:"soa_mname" form:"soa_mname"` // SOA记录的主域名服务器 + SOA_RName string `json:"soa_rname" form:"soa_rname"` // SOA记录的管理员邮箱 + SOA_Serial uint `json:"soa_serial" form:"soa_serial"` // SOA记录的序列号 + SOA_Refresh uint `json:"soa_refresh" form:"soa_refresh"` // SOA记录的刷新时间（秒） + SOA_Retry uint `json:"soa_retry" form:"soa_retry"` // SOA记录的重试时间（秒） + SOA_Expire uint `json:"soa_expire" form:"soa_expire"` // SOA记录的过期时间（秒） + SOA_Minimum uint `json:"soa_minimum" form:"soa_minimum"` // SOA记录的最小TTL（秒） + TTL uint `json:"ttl" form:"ttl"` // 默认TTL（秒） + Description string `json:"description" form:"description"` // 描述 +} + +// DNSZone 更新请求 +type UpdateDNSZoneReq struct { + ZoneID uint `json:"zone_id" form:"zone_id"` // Zone ID + Domain string `json:"domain" form:"domain"` // 域名 + SOA_MName string `json:"soa_mname" form:"soa_mname"` // SOA记录的主域名服务器 + SOA_RName string `json:"soa_rname" form:"soa_rname"` // SOA记录的管理员邮箱 + SOA_Serial uint `json:"soa_serial" form:"soa_serial"` // SOA记录的序列号 + SOA_Refresh uint `json:"soa_refresh" form:"soa_refresh"` // SOA记录的刷新时间（秒） + SOA_Retry uint `json:"soa_retry" form:"soa_retry"` // SOA记录的重试时间（秒） + SOA_Expire uint `json:"soa_expire" form:"soa_expire"` // SOA记录的过期时间（秒） + SOA_Minimum uint `json:"soa_minimum" form:"soa_minimum"` // SOA记录的最小TTL（秒） + TTL uint `json:"ttl" form:"ttl"` // 默认TTL（秒） + Description string `json:"description" form:"description"` // 描述 +} + +// DNSZone 获取请求 +type GetDNSZoneReq struct { + ZoneID uint `json:"zone_id" form:"zone_id"` // Zone ID，0表示获取全部 + ServerID uint `json:"server_id" form:"server_id"` // DNS服务器ID，用于过滤 + GetType int `json:"get_type" form:"get_type"` // 获取类型：0获取自己的，1获取全部（管理员） +} + +// DNSZone 删除请求 +type DeleteDNSZoneReq struct { + ZoneID uint `json:"zone_id" form:"zone_id"` // Zone ID + DelType uint `json:"del_type" form:"del_type"` // 删除类型：0删除单条，1删除所有 +} + +// DNSRecord 创建请求 +type CreateDNSRecordReq struct { + ZoneID uint `json:"zone_id" form:"zone_id"` // 所属Zone ID + Name string `json:"name" form:"name"` // 记录名称，如 www 或 @ + Type uint `json:"type" form:"type"` // 记录类型：1=A, 28=AAAA, 5=CNAME, 15=MX等 + Value string `json:"value" form:"value"` // 记录值 + TTL uint `json:"ttl" form:"ttl"` // TTL（秒） + Priority uint `json:"priority" form:"priority"` // 优先级（用于MX、SRV等记录） + Weight uint `json:"weight" form:"weight"` // 权重（用于SRV记录） + Port uint `json:"port" form:"port"` // 端口（用于SRV记录） + Target string `json:"target" form:"target"` // 目标（用于SRV记录） +} + +// DNSRecord 更新请求 +type UpdateDNSRecordReq struct { + RecordID uint `json:"record_id" form:"record_id"` // 记录ID + Name string `json:"name" form:"name"` // 记录名称 + Type uint `json:"type" form:"type"` // 记录类型 + Value string `json:"value" form:"value"` // 记录值 + TTL uint `json:"ttl" form:"ttl"` // TTL（秒） + Priority uint `json:"priority" form:"priority"` // 优先级 + Weight uint `json:"weight" form:"weight"` // 权重 + Port uint `json:"port" form:"port"` // 端口 + Target string `json:"target" form:"target"` // 目标 +} + +// DNSRecord 获取请求 +type GetDNSRecordReq struct { + RecordID uint `json:"record_id" form:"record_id"` // 记录ID，0表示获取全部 + ZoneID uint `json:"zone_id" form:"zone_id"` // Zone ID，用于过滤 + GetType int `json:"get_type" form:"get_type"` // 获取类型：0获取自己的，1获取全部（管理员） +} + +// DNSRecord 删除请求 +type DeleteDNSRecordReq struct { + RecordID uint `json:"record_id" form:"record_id"` // 记录ID + DelType uint `json:"del_type" form:"del_type"` // 删除类型：0删除单条，1删除所有 +} + +// 启动DNS服务器请求 +type StartDNSServerReq struct { + ServerID uint `json:"server_id" form:"server_id" binding:"required"` // DNS服务器ID +} + +// 停止DNS服务器请求 +type StopDNSServerReq struct { + ServerID uint `json:"server_id" form:"server_id" binding:"required"` // DNS服务器ID +} + +// 重启DNS服务器请求 +type RestartDNSServerReq struct { + ServerID uint `json:"server_id" form:"server_id" binding:"required"` // DNS服务器ID +} + +// 获取DNS服务器状态请求 +type GetDNSServerStatusReq struct { + ServerID uint `json:"server_id" form:"server_id" binding:"required"` // DNS服务器ID +} diff --git a/service/dnsService.go b/service/dnsService.go new file mode 100644 index 0000000..0160ea6 --- /dev/null +++ b/service/dnsService.go @@ -0,0 +1,786 @@ +package service + +import ( + "errors" + "fmt" + "net" + "sync" + "videoplayer/dao" + "videoplayer/proto" + + "github.com/miekg/dns" +) + +// DNSServiceInstance 运行中的DNS服务实例 +type DNSServiceInstance struct { + ServerID uint `json:"server_id"` + Config *proto.DNSServer `json:"config"` + Server *dns.Server `json:"-"` + Running bool `json:"running"` + mutex sync.Mutex `json:"-"` +} + +// DNSServiceManager DNS服务管理器 +type DNSServiceManager struct { + instances map[uint]*DNSServiceInstance + rwMutex sync.RWMutex +} + +var dnsServiceManager *DNSServiceManager + +func init() { + dnsServiceManager = &DNSServiceManager{ + instances: make(map[uint]*DNSServiceInstance), + } +} + +// ==================== DNSServer 相关操作 ==================== + +func CreateDNSServer(req *proto.CreateDNSServerReq, userID uint) (proto.DNSServer, error) { + server := proto.DNSServer{ + UserID: userID, + Name: req.Name, + Port: req.Port, + ListenIP: req.ListenIP, + UpstreamDNS: req.UpstreamDNS, + EnableRecursion: req.EnableRecursion, + Status: proto.DNS_STATUS_STOPPED, + Description: req.Description, + } + + if server.Port == 0 { + server.Port = 53 + } + if server.ListenIP == "" { + server.ListenIP = "0.0.0.0" + } + + id, err := dao.CreateDNSServer(server) + if err != nil { + return proto.DNSServer{}, err + } + server.ID = id + return server, nil +} + +func GetDNSServerList(req *proto.GetDNSServerReq, userID uint) ([]proto.DNSServer, error) { + var servers []proto.DNSServer + var err error + + if req.ServerID > 0 { + server, err := dao.FindDNSServerByID(req.ServerID) + if err != nil { + return nil, err + } + if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" { + return nil, errors.New("未授权访问DNS服务器") + } + servers = append(servers, server) + } else { + if req.GetType == 0 { + servers, err = dao.FindDNSServerByUserID(userID) + } else if req.GetType == 1 { + user := GetUserByIDFromUserCenter(int(userID)) + if user.Role != "admin" { + return nil, errors.New("未授权访问，仅管理员可获取全部DNS服务器") + } + servers, err = dao.FindAllDNSServer() + } else { + return nil, errors.New("无效的获取类型") + } + } + if err != nil { + return nil, err + } + return servers, nil +} + +func UpdateDNSServer(req *proto.UpdateDNSServerReq, userID int) (proto.DNSServer, error) { + server, err := dao.FindDNSServerByID(req.ServerID) + if err != nil { + return proto.DNSServer{}, err + } + if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" { + return proto.DNSServer{}, errors.New("未授权访问DNS服务器") + } + + server.Name = req.Name + server.Port = req.Port + server.ListenIP = req.ListenIP + server.UpstreamDNS = req.UpstreamDNS + server.EnableRecursion = req.EnableRecursion + server.Status = req.Status + server.Description = req.Description + + err = dao.UpdateDNSServer(server.ID, &server) + if err != nil { + return proto.DNSServer{}, err + } + + // 如果服务正在运行，自动重启以应用新配置 + go RestartDNSServerIfRunning(req.ServerID, userID) + + return server, nil +} + +func DeleteDNSServer(req *proto.DeleteDNSServerReq, userID int) error { + user := GetUserByIDFromUserCenter(userID) + if req.DelType == 0 && req.ServerID > 0 { + server, err := dao.FindDNSServerByID(req.ServerID) + if err != nil { + return err + } + if server.UserID != uint(userID) && user.Role != "admin" { + return errors.New("未授权访问DNS服务器") + } + err = dao.DeleteDNSZoneByServerID(req.ServerID) + if err != nil { + return err + } + err = dao.DeleteDNSServerByID(req.ServerID) + if err != nil { + return err + } + } else if req.DelType == 1 { + if user.Role != "admin" { + return errors.New("未授权访问，仅管理员可删除所有DNS服务器") + } + servers, err := dao.FindAllDNSServer() + if err != nil { + return err + } + for _, server := range servers { + err = dao.DeleteDNSZoneByServerID(server.ID) + if err != nil { + return err + } + err = dao.DeleteDNSServerByID(server.ID) + if err != nil { + return err + } + } + } else { + return errors.New("无效的删除类型或参数") + } + return nil +} + +// ==================== DNSZone 相关操作 ==================== + +func CreateDNSZone(req *proto.CreateDNSZoneReq, userID uint) (proto.DNSZone, error) { + server, err := dao.FindDNSServerByID(req.ServerID) + if err != nil { + return proto.DNSZone{}, err + } + if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" { + return proto.DNSZone{}, errors.New("未授权访问DNS服务器") + } + + zone := proto.DNSZone{ + ServerID: req.ServerID, + Domain: req.Domain, + SOA_MName: req.SOA_MName, + SOA_RName: req.SOA_RName, + SOA_Serial: req.SOA_Serial, + SOA_Refresh: req.SOA_Refresh, + SOA_Retry: req.SOA_Retry, + SOA_Expire: req.SOA_Expire, + SOA_Minimum: req.SOA_Minimum, + TTL: req.TTL, + Description: req.Description, + } + + if zone.SOA_Serial == 0 { + zone.SOA_Serial = 1 + } + if zone.SOA_Refresh == 0 { + zone.SOA_Refresh = 86400 + } + if zone.SOA_Retry == 0 { + zone.SOA_Retry = 7200 + } + if zone.SOA_Expire == 0 { + zone.SOA_Expire = 3600000 + } + if zone.SOA_Minimum == 0 { + zone.SOA_Minimum = 3600 + } + if zone.TTL == 0 { + zone.TTL = 3600 + } + + id, err := dao.CreateDNSZone(zone) + if err != nil { + return proto.DNSZone{}, err + } + zone.ID = id + return zone, nil +} + +func GetDNSZoneList(req *proto.GetDNSZoneReq, userID uint) ([]proto.DNSZone, error) { + var zones []proto.DNSZone + var err error + + if req.ZoneID > 0 { + zone, err := dao.FindDNSZoneByID(req.ZoneID) + if err != nil { + return nil, err + } + server, err := dao.FindDNSServerByID(zone.ServerID) + if err != nil { + return nil, err + } + if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" { + return nil, errors.New("未授权访问DNS区域") + } + zones = append(zones, zone) + } else { + if req.GetType == 0 { + if req.ServerID > 0 { + zones, err = dao.FindDNSZoneByServerID(req.ServerID) + } else { + servers, err := dao.FindDNSServerByUserID(userID) + if err != nil { + return nil, err + } + for _, server := range servers { + serverZones, err := dao.FindDNSZoneByServerID(server.ID) + if err != nil { + return nil, err + } + zones = append(zones, serverZones...) + } + } + } else if req.GetType == 1 { + user := GetUserByIDFromUserCenter(int(userID)) + if user.Role != "admin" { + return nil, errors.New("未授权访问，仅管理员可获取全部DNS区域") + } + if req.ServerID > 0 { + zones, err = dao.FindDNSZoneByServerID(req.ServerID) + } else { + zones, err = dao.FindAllDNSZone() + } + } else { + return nil, errors.New("无效的获取类型") + } + } + if err != nil { + return nil, err + } + return zones, nil +} + +func UpdateDNSZone(req *proto.UpdateDNSZoneReq, userID int) (proto.DNSZone, error) { + zone, err := dao.FindDNSZoneByID(req.ZoneID) + if err != nil { + return proto.DNSZone{}, err + } + server, err := dao.FindDNSServerByID(zone.ServerID) + if err != nil { + return proto.DNSZone{}, err + } + if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" { + return proto.DNSZone{}, errors.New("未授权访问DNS区域") + } + + zone.Domain = req.Domain + zone.SOA_MName = req.SOA_MName + zone.SOA_RName = req.SOA_RName + zone.SOA_Serial = req.SOA_Serial + zone.SOA_Refresh = req.SOA_Refresh + zone.SOA_Retry = req.SOA_Retry + zone.SOA_Expire = req.SOA_Expire + zone.SOA_Minimum = req.SOA_Minimum + zone.TTL = req.TTL + zone.Description = req.Description + + err = dao.UpdateDNSZone(zone.ID, &zone) + if err != nil { + return proto.DNSZone{}, err + } + return zone, nil +} + +func DeleteDNSZone(req *proto.DeleteDNSZoneReq, userID int) error { + user := GetUserByIDFromUserCenter(userID) + if req.DelType == 0 && req.ZoneID > 0 { + zone, err := dao.FindDNSZoneByID(req.ZoneID) + if err != nil { + return err + } + server, err := dao.FindDNSServerByID(zone.ServerID) + if err != nil { + return err + } + if server.UserID != uint(userID) && user.Role != "admin" { + return errors.New("未授权访问DNS区域") + } + err = dao.DeleteDNSRecordByZoneID(req.ZoneID) + if err != nil { + return err + } + err = dao.DeleteDNSZoneByID(req.ZoneID) + if err != nil { + return err + } + } else if req.DelType == 1 { + if user.Role != "admin" { + return errors.New("未授权访问，仅管理员可删除所有DNS区域") + } + zones, err := dao.FindAllDNSZone() + if err != nil { + return err + } + for _, zone := range zones { + err = dao.DeleteDNSRecordByZoneID(zone.ID) + if err != nil { + return err + } + err = dao.DeleteDNSZoneByID(zone.ID) + if err != nil { + return err + } + } + } else { + return errors.New("无效的删除类型或参数") + } + return nil +} + +// ==================== DNSRecord 相关操作 ==================== + +func CreateDNSRecord(req *proto.CreateDNSRecordReq, userID uint) (proto.DNSRecord, error) { + zone, err := dao.FindDNSZoneByID(req.ZoneID) + if err != nil { + return proto.DNSRecord{}, err + } + server, err := dao.FindDNSServerByID(zone.ServerID) + if err != nil { + return proto.DNSRecord{}, err + } + if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" { + return proto.DNSRecord{}, errors.New("未授权访问DNS区域") + } + + record := proto.DNSRecord{ + ZoneID: req.ZoneID, + Name: req.Name, + Type: req.Type, + Value: req.Value, + TTL: req.TTL, + Priority: req.Priority, + Weight: req.Weight, + Port: req.Port, + Target: req.Target, + } + + if record.TTL == 0 { + record.TTL = zone.TTL + } + + id, err := dao.CreateDNSRecord(record) + if err != nil { + return proto.DNSRecord{}, err + } + record.ID = id + return record, nil +} + +func GetDNSRecordList(req *proto.GetDNSRecordReq, userID uint) ([]proto.DNSRecord, error) { + var records []proto.DNSRecord + var err error + + if req.RecordID > 0 { + record, err := dao.FindDNSRecordByID(req.RecordID) + if err != nil { + return nil, err + } + zone, err := dao.FindDNSZoneByID(record.ZoneID) + if err != nil { + return nil, err + } + server, err := dao.FindDNSServerByID(zone.ServerID) + if err != nil { + return nil, err + } + if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" { + return nil, errors.New("未授权访问DNS记录") + } + records = append(records, record) + } else { + if req.GetType == 0 { + if req.ZoneID > 0 { + records, err = dao.FindDNSRecordByZoneID(req.ZoneID) + } else { + servers, err := dao.FindDNSServerByUserID(userID) + if err != nil { + return nil, err + } + for _, server := range servers { + zones, err := dao.FindDNSZoneByServerID(server.ID) + if err != nil { + return nil, err + } + for _, zone := range zones { + zoneRecords, err := dao.FindDNSRecordByZoneID(zone.ID) + if err != nil { + return nil, err + } + records = append(records, zoneRecords...) + } + } + } + } else if req.GetType == 1 { + user := GetUserByIDFromUserCenter(int(userID)) + if user.Role != "admin" { + return nil, errors.New("未授权访问，仅管理员可获取全部DNS记录") + } + if req.ZoneID > 0 { + records, err = dao.FindDNSRecordByZoneID(req.ZoneID) + } else { + records, err = dao.FindAllDNSRecord() + } + } else { + return nil, errors.New("无效的获取类型") + } + } + if err != nil { + return nil, err + } + return records, nil +} + +func UpdateDNSRecord(req *proto.UpdateDNSRecordReq, userID int) (proto.DNSRecord, error) { + record, err := dao.FindDNSRecordByID(req.RecordID) + if err != nil { + return proto.DNSRecord{}, err + } + zone, err := dao.FindDNSZoneByID(record.ZoneID) + if err != nil { + return proto.DNSRecord{}, err + } + server, err := dao.FindDNSServerByID(zone.ServerID) + if err != nil { + return proto.DNSRecord{}, err + } + if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" { + return proto.DNSRecord{}, errors.New("未授权访问DNS记录") + } + + record.Name = req.Name + record.Type = req.Type + record.Value = req.Value + record.TTL = req.TTL + record.Priority = req.Priority + record.Weight = req.Weight + record.Port = req.Port + record.Target = req.Target + + err = dao.UpdateDNSRecord(record.ID, &record) + if err != nil { + return proto.DNSRecord{}, err + } + return record, nil +} + +func DeleteDNSRecord(req *proto.DeleteDNSRecordReq, userID int) error { + user := GetUserByIDFromUserCenter(userID) + if req.DelType == 0 && req.RecordID > 0 { + record, err := dao.FindDNSRecordByID(req.RecordID) + if err != nil { + return err + } + zone, err := dao.FindDNSZoneByID(record.ZoneID) + if err != nil { + return err + } + server, err := dao.FindDNSServerByID(zone.ServerID) + if err != nil { + return err + } + if server.UserID != uint(userID) && user.Role != "admin" { + return errors.New("未授权访问DNS记录") + } + err = dao.DeleteDNSRecordByID(req.RecordID) + if err != nil { + return err + } + } else if req.DelType == 1 { + if user.Role != "admin" { + return errors.New("未授权访问，仅管理员可删除所有DNS记录") + } + records, err := dao.FindAllDNSRecord() + if err != nil { + return err + } + for _, record := range records { + err = dao.DeleteDNSRecordByID(record.ID) + if err != nil { + return err + } + } + } else { + return errors.New("无效的删除类型或参数") + } + return nil +} + +// ==================== DNS 服务运行管理 ==================== + +// handleDNSRequest 处理DNS查询请求 +func (instance *DNSServiceInstance) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) { + m := new(dns.Msg) + m.SetReply(r) + m.Authoritative = true + + for _, q := range r.Question { + // 查找对应的Zone + zones, err := dao.FindDNSZoneByServerID(instance.ServerID) + if err != nil { + continue + } + + var matchedZone *proto.DNSZone + var qName string = dns.Fqdn(q.Name) + + for _, zone := range zones { + zoneFqdn := dns.Fqdn(zone.Domain) + if dns.IsSubDomain(zoneFqdn, qName) { + matchedZone = &zone + break + } + } + + if matchedZone == nil { + // 递归查询 + if instance.Config.EnableRecursion { + c := new(dns.Client) + upstreams := instance.Config.UpstreamDNS + if upstreams == "" { + upstreams = "8.8.8.8:53" + } + resp, _, err := c.Exchange(r, upstreams) + if err == nil { + m.Answer = append(m.Answer, resp.Answer...) + } + } + continue + } + + // 查找匹配的记录 + records, err := dao.FindDNSRecordByZoneID(matchedZone.ID) + if err != nil { + continue + } + + for _, record := range records { + recordName := dns.Fqdn(record.Name + "." + matchedZone.Domain) + if record.Name == "@" { + recordName = dns.Fqdn(matchedZone.Domain) + } + + if recordName == qName && record.Type == uint(q.Qtype) { + var rr dns.RR + var ttl uint32 + if record.TTL > 0 { + ttl = uint32(record.TTL) + } else { + ttl = uint32(matchedZone.TTL) + } + + switch q.Qtype { + case dns.TypeA: + rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN A %s", q.Name, ttl, record.Value)) + case dns.TypeAAAA: + rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN AAAA %s", q.Name, ttl, record.Value)) + case dns.TypeCNAME: + rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN CNAME %s", q.Name, ttl, record.Value)) + case dns.TypeMX: + rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN MX %d %s", q.Name, ttl, record.Priority, record.Value)) + case dns.TypeNS: + rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN NS %s", q.Name, ttl, record.Value)) + case dns.TypeTXT: + rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN TXT \"%s\"", q.Name, ttl, record.Value)) + case dns.TypeSRV: + rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN SRV %d %d %d %s", q.Name, ttl, record.Priority, record.Weight, record.Port, record.Target)) + } + + if rr != nil { + m.Answer = append(m.Answer, rr) + } + } + } + } + + w.WriteMsg(m) +} + +// StartDNSServer 启动DNS服务 +func StartDNSServer(serverID uint, userID int) (*DNSServiceInstance, error) { + // 检查权限 + server, err := dao.FindDNSServerByID(serverID) + if err != nil { + return nil, err + } + if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" { + return nil, errors.New("未授权访问DNS服务器") + } + + dnsServiceManager.rwMutex.Lock() + defer dnsServiceManager.rwMutex.Unlock() + + // 检查是否已经在运行 + if instance, exists := dnsServiceManager.instances[serverID]; exists && instance.Running { + return instance, nil + } + + // 创建服务实例 + instance := &DNSServiceInstance{ + ServerID: serverID, + Config: &server, + Running: false, + } + + // 创建DNS服务器 + dns.HandleFunc(".", instance.handleDNSRequest) + + addr := fmt.Sprintf("%s:%d", server.ListenIP, server.Port) + udpAddr, err := net.ResolveUDPAddr("udp", addr) + if err != nil { + return nil, err + } + + udpConn, err := net.ListenUDP("udp", udpAddr) + if err != nil { + return nil, err + } + + tcpAddr, err := net.ResolveTCPAddr("tcp", addr) + if err != nil { + udpConn.Close() + return nil, err + } + + tcpListener, err := net.ListenTCP("tcp", tcpAddr) + if err != nil { + udpConn.Close() + return nil, err + } + + instance.Server = &dns.Server{ + Listener: tcpListener, + PacketConn: udpConn, + } + + // 启动服务 + go func() { + instance.mutex.Lock() + instance.Running = true + instance.mutex.Unlock() + + err := instance.Server.ActivateAndServe() + if err != nil { + instance.mutex.Lock() + instance.Running = false + instance.mutex.Unlock() + } + }() + + // 更新数据库状态 + server.Status = proto.DNS_STATUS_RUNNING + dao.UpdateDNSServer(serverID, &server) + + dnsServiceManager.instances[serverID] = instance + return instance, nil +} + +// StopDNSServer 停止DNS服务 +func StopDNSServer(serverID uint, userID int) error { + server, err := dao.FindDNSServerByID(serverID) + if err != nil { + return err + } + if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" { + return errors.New("未授权访问DNS服务器") + } + + dnsServiceManager.rwMutex.Lock() + defer dnsServiceManager.rwMutex.Unlock() + + instance, exists := dnsServiceManager.instances[serverID] + if !exists || !instance.Running { + return nil + } + + // 停止服务 + err = instance.Server.Shutdown() + if err != nil { + return err + } + + instance.mutex.Lock() + instance.Running = false + instance.mutex.Unlock() + + // 更新数据库状态 + server.Status = proto.DNS_STATUS_STOPPED + dao.UpdateDNSServer(serverID, &server) + + delete(dnsServiceManager.instances, serverID) + return nil +} + +// RestartDNSServer 重启DNS服务 +func RestartDNSServer(serverID uint, userID int) (*DNSServiceInstance, error) { + err := StopDNSServer(serverID, userID) + if err != nil { + return nil, err + } + return StartDNSServer(serverID, userID) +} + +// GetDNSServerStatus 获取DNS服务运行状态 +func GetDNSServerStatus(serverID uint, userID int) (*DNSServiceInstance, error) { + server, err := dao.FindDNSServerByID(serverID) + if err != nil { + return nil, err + } + if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" { + return nil, errors.New("未授权访问DNS服务器") + } + + dnsServiceManager.rwMutex.RLock() + defer dnsServiceManager.rwMutex.RUnlock() + + instance, exists := dnsServiceManager.instances[serverID] + if exists { + return instance, nil + } + + // 不在运行中，返回配置中的状态 + return &DNSServiceInstance{ + ServerID: serverID, + Config: &server, + Running: server.Status == proto.DNS_STATUS_RUNNING, + }, nil +} + +// RestartDNSServerIfRunning 如果服务正在运行则重启（配置更新时调用） +func RestartDNSServerIfRunning(serverID uint, userID int) error { + dnsServiceManager.rwMutex.RLock() + instance, exists := dnsServiceManager.instances[serverID] + dnsServiceManager.rwMutex.RUnlock() + + if exists && instance.Running { + // 获取最新配置 + server, err := dao.FindDNSServerByID(serverID) + if err != nil { + return err + } + // 重启服务（管理员权限） + _, err = RestartDNSServer(server.ID, userID) // 假设管理员ID为1 + return err + } + return nil +} diff --git a/service/shellService.go b/service/shellService.go index 48bc351..302d4cc 100644 --- a/service/shellService.go +++ b/service/shellService.go @@ -1,7 +1,6 @@ package service import ( - "bytes" "errors" "log" "os/exec"