feat(ldap): add ldap protocol support (#50)

Co-authored-by: tardc <[email protected]>
Co-authored-by: E99p1ant <[email protected]>

pkg/dns/rule.go

@@ -101,10 +101,7 @@ func ListRules(c *gin.Context) {
 	}
 
 	db := database.DB.Model(&dnsRule)
-	if dnsRule.Name != "" {
-		db.Where("name = ?", dnsRule.Name)
-	}
-	db.Count(&count)
+	db.Where(&dnsRule).Count(&count)
 
 	page, err := strconv.Atoi(c.Query("page"))
 	if err != nil {
@@ -138,10 +135,7 @@ func ListRules(c *gin.Context) {
 
 // UpsertRules creates or updates dns rule from user submit
 func UpsertRules(c *gin.Context) {
-	var (
-		dnsRule Rule
-		update  bool
-	)
+	var dnsRule Rule
 
 	if err := c.ShouldBind(&dnsRule); err != nil {
 		c.JSON(400, gin.H{
@@ -152,10 +146,6 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if dnsRule.ID != 0 {
-		update = true
-	}
-
 	if err := dnsRule.CreateOrUpdate(); err != nil {
 		c.JSON(400, gin.H{
 			"status": "failed",
@@ -165,7 +155,7 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if update {
+	if dnsRule.ID != 0 {
 		log.Trace("DNS rule[id:%d] has been updated", dnsRule.ID)
 	} else {
 		log.Trace("DNS rule[id:%d] has been created", dnsRule.ID)

pkg/ftp/ftp.go

@@ -395,10 +395,10 @@ func (s *Server) Run() {
 		}
 	}()
 
-	for s.Enable {
+	for {
 		tcpConn, err := listener.Accept()
 		if err != nil {
-			if !strings.Contains(err.Error(), net.ErrClosed.Error()) {
+			if !errors.Is(err, net.ErrClosed) {
 				log.Warn("FTP accept connection error: %v", err)
 			} else {
 				break

pkg/ftp/rule.go

@@ -96,10 +96,7 @@ func ListRules(c *gin.Context) {
 	}
 
 	db := database.DB.Model(&ftpRule)
-	if ftpRule.Name != "" {
-		db.Where("name = ?", ftpRule.Name)
-	}
-	db.Count(&count)
+	db.Where(&ftpRule).Count(&count)
 
 	page, err := strconv.Atoi(c.Query("page"))
 	if err != nil {
@@ -133,10 +130,7 @@ func ListRules(c *gin.Context) {
 
 // UpsertRules creates or updates ftp rule from user submit
 func UpsertRules(c *gin.Context) {
-	var (
-		ftpRule Rule
-		update  bool
-	)
+	var ftpRule Rule
 
 	if err := c.ShouldBind(&ftpRule); err != nil {
 		c.JSON(400, gin.H{
@@ -147,10 +141,6 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if ftpRule.ID != 0 {
-		update = true
-	}
-
 	if err := ftpRule.CreateOrUpdate(); err != nil {
 		c.JSON(400, gin.H{
 			"status": "failed",
@@ -160,7 +150,7 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if update {
+	if ftpRule.ID != 0 {
 		log.Trace("FTP rule[id:%d] has been updated", ftpRule.ID)
 	} else {
 		log.Trace("FTP rule[id:%d] has been created", ftpRule.ID)

pkg/ldap/config.go

@@ -0,0 +1,6 @@
+package ldap
+
+type Config struct {
+	Enable bool
+	Addr   string
+}

pkg/ldap/ldap.go

@@ -0,0 +1,197 @@
+package ldap
+
+import (
+	"bytes"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/li4n0/revsuit/internal/database"
+	"github.com/li4n0/revsuit/internal/ipinfo"
+	"github.com/li4n0/revsuit/internal/recycler"
+	"github.com/pkg/errors"
+	log "unknwon.dev/clog/v2"
+)
+
+type Server struct {
+	Config
+	rules      []*Rule
+	rulesLock  sync.RWMutex
+	livingLock sync.Mutex
+}
+
+var (
+	server *Server
+	once   sync.Once
+)
+
+func GetServer() *Server {
+	once.Do(func() {
+		server = &Server{rulesLock: sync.RWMutex{}, livingLock: sync.Mutex{}}
+	})
+	return server
+}
+
+func (s *Server) getRules() []*Rule {
+	defer s.rulesLock.RUnlock()
+	s.rulesLock.RLock()
+	return s.rules
+}
+
+func (s *Server) UpdateRules() error {
+	db := database.DB.Model(new(Rule))
+	defer s.rulesLock.Unlock()
+	s.rulesLock.Lock()
+	return errors.Wrap(db.Order("base_rank desc").Find(&s.rules).Error, "LDAP update rules error")
+}
+
+func (s *Server) handleConnection(conn net.Conn) {
+	defer func() {
+		_ = conn.Close()
+		if err := recover(); err != nil {
+			recycler.Recycle(err)
+		}
+	}()
+
+	if err := conn.SetDeadline(time.Now().Add(time.Second * 30)); err != nil {
+		log.Warn("LDAP set connection deadline error:%v", err)
+		return
+	}
+
+	ip, _, _ := net.SplitHostPort(conn.RemoteAddr().String())
+
+	buf := make([]byte, 1024)
+	_, err := conn.Read(buf)
+	if err != nil {
+		log.Warn("LDAP read connection error:%v", err)
+		return
+	}
+
+	if !bytes.Contains(buf, []byte{
+		0x30, 0x0c, 0x02, 0x01, 0x01, 0x60, 0x07,
+		0x02, 0x01, 0x03, 0x04, 0x00, 0x80, 0x00}) {
+		return
+	}
+
+	send := []byte{
+		0x30, 0x0c, 0x02, 0x01, 0x01, 0x61, 0x07,
+		0x0a, 0x01, 0x00, 0x04, 0x00, 0x04, 0x00,
+	}
+	_, err = conn.Write(send)
+	if err != nil {
+		log.Warn("LDAP write connection error: %v", err)
+		return
+	}
+	_, err = conn.Read(buf)
+	if err != nil {
+		log.Warn("LDAP read connection error:%v", err)
+		return
+	}
+
+	length := buf[8]
+	pathBytes := bytes.Buffer{}
+	for i := 1; i <= int(length); i++ {
+		temp := []byte{buf[8+i]}
+		pathBytes.Write(temp)
+	}
+	path := pathBytes.String()
+
+	for _, _rule := range s.getRules() {
+		flag, flagGroup, _ := _rule.Match(path)
+		if flag == "" {
+			continue
+		}
+
+		area := ipinfo.Area(ip)
+
+		// create new record
+		r, err := NewRecord(_rule, flag, path, ip, area)
+		if err != nil {
+			log.Warn("LDAP record[rule_id:%d] created failed :%s", _rule.ID, err)
+			return
+		}
+		log.Info("LDAP record[id:%d rule:%s remote_ip:%s] has been created", r.ID, _rule.Name, ip)
+
+		//only send to client when this connection recorded first time.
+		if _rule.PushToClient {
+			if flagGroup != "" {
+				var count int64
+				database.DB.Where("rule_name=? and path like ?", _rule.Name, "%"+flagGroup+"%").Model(&Record{}).Count(&count)
+				if count <= 1 {
+					r.PushToClient()
+					log.Trace("LDAP record[id:%d, flagGroup:%s] has been put to client message queue", r.ID, flagGroup)
+				}
+			} else {
+				r.PushToClient()
+				log.Trace("LDAP record[id:%d, flag:%s] has been put to client message queue", r.ID, flag)
+			}
+		}
+
+		//send notice
+		if _rule.Notice {
+			go func() {
+				r.Notice()
+				log.Trace("LDAP record[id:%d] notice has been sent", r.ID)
+			}()
+		}
+		return
+	}
+}
+
+func (s *Server) Stop() {
+	log.Info("LDAP Server is stopping...")
+	s.Enable = false
+	s.livingLock.Unlock()
+}
+
+func (s *Server) Restart() {
+	s.Stop()
+	time.Sleep(time.Second * 2)
+	go s.Run()
+}
+
+func (s *Server) Run() {
+	s.Enable = true
+	s.livingLock.Lock()
+	defer func() {
+		if s.Enable {
+			log.Error("LDAP Server exited unexpectedly")
+		}
+		s.Enable = false
+		s.livingLock.Unlock()
+	}()
+
+	if err := s.UpdateRules(); err != nil {
+		log.Error(err.Error())
+		return
+	}
+
+	// run server
+	log.Info("Starting LDAP Server at %v", s.Addr)
+
+	listener, err := net.Listen("tcp", s.Addr)
+	if err != nil {
+		log.Error(err.Error())
+		return
+	}
+
+	go func() {
+		s.livingLock.Lock()
+		if !s.Enable {
+			_ = listener.Close()
+		}
+	}()
+
+	for {
+		tcpConn, err := listener.Accept()
+		if err != nil {
+			if !errors.Is(err, net.ErrClosed) {
+				log.Warn("LDAP accept connection error: %v", err)
+			} else {
+				break
+			}
+			continue
+		}
+		go s.handleConnection(tcpConn)
+	}
+}

pkg/ldap/record.go

@@ -0,0 +1,139 @@
+package ldap
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/li4n0/revsuit/internal/database"
+	"github.com/li4n0/revsuit/internal/notice"
+	"github.com/li4n0/revsuit/internal/record"
+	"gorm.io/gorm"
+	log "unknwon.dev/clog/v2"
+)
+
+var _ record.Record = (*Record)(nil)
+
+type Record struct {
+	Path string `form:"path" json:"path"`
+	record.BaseRecord
+	Rule Rule `gorm:"foreignKey:RuleName;references:Name;constraint:OnUpdate:CASCADE,OnDelete:SET NULL;" form:"-" json:"-" notice:"-"`
+}
+
+func (Record) TableName() string {
+	return "ldap_records"
+}
+
+func (r Record) Notice() {
+	notice.Notice(r)
+}
+
+func NewRecord(rule *Rule, flag, path, ip, area string) (r *Record, err error) {
+	r = &Record{
+		BaseRecord: record.BaseRecord{
+			Flag:        flag,
+			RemoteIP:    ip,
+			IpArea:      area,
+			RequestTime: time.Now(),
+		},
+		Path: path,
+		Rule: *rule,
+	}
+	return r, database.DB.Create(r).Error
+}
+
+func Records(c *gin.Context) {
+	var (
+		ldapRecord Record
+		res        []Record
+		count      int64
+		order      = c.Query("order")
+		pageSize   = 10
+	)
+
+	if c.Query("pageSize") != "" {
+		if n, err := strconv.Atoi(c.Query("pageSize")); err == nil {
+			if n > 0 && n < 100 {
+				pageSize = n
+			}
+		}
+	}
+
+	if err := c.ShouldBind(&ldapRecord); err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"result": nil,
+		})
+		return
+	}
+
+	db := database.DB.Model(&ldapRecord)
+	if ldapRecord.Flag != "" {
+		db.Where("flag = ?", ldapRecord.Flag)
+	}
+	if ldapRecord.Path != "" {
+		db.Where("path like ?", "%"+ldapRecord.Path+"%")
+	}
+	if ldapRecord.RemoteIP != "" {
+		db.Where("remote_ip = ?", ldapRecord.RemoteIP)
+	}
+	if ldapRecord.RuleName != "" {
+		db.Where("rule_name = ?", ldapRecord.RuleName)
+	}
+
+	//Delete records
+	if c.Request.Method == http.MethodDelete {
+		if err := db.Session(&gorm.Session{AllowGlobalUpdate: true}).Delete(&res).Error; err != nil {
+			c.JSON(400, gin.H{
+				"status": "failed",
+				"error":  err.Error(),
+				"data":   nil,
+			})
+			return
+		}
+
+		if database.Driver == database.Sqlite {
+			db.Exec("VACUUM")
+		}
+
+		c.JSON(200, gin.H{
+			"status": "succeed",
+			"error":  nil,
+		})
+
+		log.Info("%d ldap records deleted by %s", db.RowsAffected, c.Request.RemoteAddr)
+		return
+	}
+
+	//List records
+	page, err := strconv.Atoi(c.Query("page"))
+	if err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"result": nil,
+		})
+		return
+	}
+
+	if order != "asc" {
+		order = "desc"
+	}
+
+	if err := db.Order("id" + " " + order).Count(&count).Offset((page - 1) * pageSize).Limit(pageSize).Find(&res).Error; err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"data":   nil,
+		})
+		return
+	}
+
+	c.JSON(200, gin.H{
+		"status": "succeed",
+		"error":  nil,
+		"result": gin.H{"count": count, "data": res},
+	})
+}

pkg/ldap/rule.go

@@ -0,0 +1,192 @@
+package ldap
+
+import (
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/li4n0/revsuit/internal/database"
+	"github.com/li4n0/revsuit/internal/rule"
+	"gorm.io/gorm/clause"
+	log "unknwon.dev/clog/v2"
+)
+
+// Rule LDAP rule struct
+type Rule struct {
+	rule.BaseRule `yaml:",inline"`
+}
+
+func (Rule) TableName() string {
+	return "ldap_rules"
+}
+
+// NewRule new ldap rule struct
+func NewRule(name, flagFormat string, pushToClient, notice bool) *Rule {
+	return &Rule{
+		BaseRule: rule.BaseRule{
+			Name:         name,
+			FlagFormat:   flagFormat,
+			PushToClient: pushToClient,
+			Notice:       notice,
+		},
+	}
+}
+
+// CreateOrUpdate creates or updates the ldap rule in database and ruleSet
+func (r *Rule) CreateOrUpdate() (err error) {
+	db := database.DB.Model(r)
+	err = db.Clauses(clause.OnConflict{
+		Columns: []clause.Column{{Name: "id"}},
+		DoUpdates: clause.AssignmentColumns(
+			[]string{
+				"name",
+				"flag_format",
+				"base_rank",
+				"push_to_client",
+				"notice",
+			}),
+	}).Create(r).Error
+	if err != nil {
+		return
+	}
+
+	err = GetServer().UpdateRules()
+	return err
+}
+
+// Delete deletes the ldap rule in database and ruleSet
+func (r *Rule) Delete() (err error) {
+	db := database.DB.Model(r)
+	err = db.Delete(r).Error
+	if err != nil {
+		return
+	}
+
+	err = GetServer().UpdateRules()
+	return err
+}
+
+// ListRules lists all ldap rules those satisfy the filter
+func ListRules(c *gin.Context) {
+	var (
+		ldapRule Rule
+		res      []Rule
+		count    int64
+		order    = c.Query("order")
+		pageSize = 10
+	)
+
+	if c.Query("pageSize") != "" {
+		if n, err := strconv.Atoi(c.Query("pageSize")); err == nil {
+			if n > 0 && n < 100 {
+				pageSize = n
+			}
+		}
+	}
+
+	if err := c.ShouldBind(&ldapRule); err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"result": nil,
+		})
+		return
+	}
+
+	db := database.DB.Model(&ldapRule)
+	db.Where(&ldapRule).Count(&count)
+
+	page, err := strconv.Atoi(c.Query("page"))
+	if err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"result": nil,
+		})
+		return
+	}
+
+	if order != "asc" {
+		order = "desc"
+	}
+
+	if err := db.Order("base_rank desc").Order("id" + " " + order).Count(&count).Offset((page - 1) * pageSize).Limit(pageSize).Find(&res).Error; err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"data":   nil,
+		})
+		return
+	}
+
+	c.JSON(200, gin.H{
+		"status": "succeed",
+		"error":  nil,
+		"result": gin.H{"count": count, "data": res},
+	})
+}
+
+// UpsertRules creates or updates ldap rule from user submit
+func UpsertRules(c *gin.Context) {
+	var ldapRule Rule
+
+	if err := c.ShouldBind(&ldapRule); err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"data":   nil,
+		})
+		return
+	}
+
+	if err := ldapRule.CreateOrUpdate(); err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"result": nil,
+		})
+		return
+	}
+
+	if ldapRule.ID != 0 {
+		log.Trace("LDAP rule[id:%d] has been updated", ldapRule.ID)
+	} else {
+		log.Trace("LDAP rule[id:%d] has been created", ldapRule.ID)
+	}
+
+	c.JSON(200, gin.H{
+		"status": "succeed",
+		"error":  nil,
+		"result": nil,
+	})
+}
+
+// DeleteRules deletes ldap rule from user submit
+func DeleteRules(c *gin.Context) {
+	var ldapRule Rule
+
+	if err := c.ShouldBind(&ldapRule); err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"data":   nil,
+		})
+		return
+	}
+
+	if err := ldapRule.Delete(); err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"data":   nil,
+		})
+		return
+	}
+
+	log.Trace("LDAP rule[id:%d] has been deleted", ldapRule.ID)
+
+	c.JSON(200, gin.H{
+		"status": "succeed",
+		"error":  nil,
+		"data":   nil,
+	})
+}

pkg/mysql/rule.go

@@ -84,10 +84,7 @@ func ListRules(c *gin.Context) {
 	}
 
 	db := database.DB.Model(&mysqlRule)
-	if mysqlRule.Name != "" {
-		db.Where("name = ?", mysqlRule.Name)
-	}
-	db.Count(&count)
+	db.Where(&mysqlRule).Count(&count)
 
 	page, err := strconv.Atoi(c.Query("page"))
 	if err != nil {
@@ -121,10 +118,7 @@ func ListRules(c *gin.Context) {
 
 // UpsertRules create or update mysql rule from user submit
 func UpsertRules(c *gin.Context) {
-	var (
-		mysqlRule Rule
-		update    bool
-	)
+	var mysqlRule Rule
 
 	if err := c.ShouldBind(&mysqlRule); err != nil {
 		c.JSON(400, gin.H{
@@ -135,10 +129,6 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if mysqlRule.ID != 0 {
-		update = true
-	}
-
 	if err := mysqlRule.CreateOrUpdate(); err != nil {
 		c.JSON(400, gin.H{
 			"status": "failed",
@@ -148,7 +138,7 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if update {
+	if mysqlRule.ID != 0 {
 		log.Trace("MySQL rule[id:%d] has been updated", mysqlRule.ID)
 	} else {
 		log.Trace("MySQL rule[id:%d] has been created", mysqlRule.ID)

pkg/rhttp/rule.go

@@ -102,10 +102,7 @@ func ListRules(c *gin.Context) {
 	}
 
 	db := database.DB.Model(&httpRule)
-	if httpRule.Name != "" {
-		db.Where("name = ?", httpRule.Name)
-	}
-	db.Count(&count)
+	db.Where(&httpRule).Count(&count)
 
 	page, err := strconv.Atoi(c.Query("page"))
 	if err != nil {
@@ -139,10 +136,7 @@ func ListRules(c *gin.Context) {
 
 // UpsertRules create or update http rule from user submit
 func UpsertRules(c *gin.Context) {
-	var (
-		httpRule Rule
-		update   bool
-	)
+	var httpRule Rule
 
 	if err := c.ShouldBind(&httpRule); err != nil {
 		c.JSON(400, gin.H{
@@ -153,10 +147,6 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if httpRule.ID != 0 {
-		update = true
-	}
-
 	if err := httpRule.CreateOrUpdate(); err != nil {
 		c.JSON(400, gin.H{
 			"status": "failed",
@@ -166,7 +156,7 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if update {
+	if httpRule.ID != 0 {
 		log.Trace("HTTP rule[id:%d] has been updated", httpRule.ID)
 	} else {
 		log.Trace("HTTP rule[id:%d] has been created", httpRule.ID)

pkg/rmi/rmi.go

@@ -191,10 +191,10 @@ func (s *Server) Run() {
 		}
 	}()
 
-	for s.Enable {
+	for {
 		tcpConn, err := listener.Accept()
 		if err != nil {
-			if !strings.Contains(err.Error(), net.ErrClosed.Error()) {
+			if !errors.Is(err, net.ErrClosed) {
 				log.Warn("RMI accept connection error: %v", err)
 			} else {
 				break

pkg/rmi/rule.go

@@ -93,10 +93,7 @@ func ListRules(c *gin.Context) {
 	}
 
 	db := database.DB.Model(&rmiRule)
-	if rmiRule.Name != "" {
-		db.Where("name = ?", rmiRule.Name)
-	}
-	db.Count(&count)
+	db.Where(&rmiRule).Count(&count)
 
 	page, err := strconv.Atoi(c.Query("page"))
 	if err != nil {
@@ -130,10 +127,7 @@ func ListRules(c *gin.Context) {
 
 // UpsertRules creates or updates rmi rule from user submit
 func UpsertRules(c *gin.Context) {
-	var (
-		rmiRule Rule
-		update  bool
-	)
+	var rmiRule Rule
 
 	if err := c.ShouldBind(&rmiRule); err != nil {
 		c.JSON(400, gin.H{
@@ -144,10 +138,6 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if rmiRule.ID != 0 {
-		update = true
-	}
-
 	if err := rmiRule.CreateOrUpdate(); err != nil {
 		c.JSON(400, gin.H{
 			"status": "failed",
@@ -157,7 +147,7 @@ func UpsertRules(c *gin.Context) {
 		return
 	}
 
-	if update {
+	if rmiRule.ID != 0 {
 		log.Trace("RMI rule[id:%d] has been updated", rmiRule.ID)
 	} else {
 		log.Trace("RMI rule[id:%d] has been created", rmiRule.ID)

pkg/server/config.go

@@ -4,6 +4,7 @@ import (
 	"github.com/li4n0/revsuit/internal/ipinfo"
 	"github.com/li4n0/revsuit/pkg/dns"
 	"github.com/li4n0/revsuit/pkg/ftp"
+	"github.com/li4n0/revsuit/pkg/ldap"
 	"github.com/li4n0/revsuit/pkg/mysql"
 	"github.com/li4n0/revsuit/pkg/rhttp"
 	"github.com/li4n0/revsuit/pkg/rmi"
@@ -31,5 +32,6 @@ type Config struct {
 	DNS                dns.Config
 	MySQL              mysql.Config
 	RMI                rmi.Config
+	LDAP               ldap.Config
 	FTP                ftp.Config
 }

pkg/server/router.go

@@ -10,6 +10,7 @@ import (
 	"github.com/li4n0/revsuit/internal/file"
 	"github.com/li4n0/revsuit/pkg/dns"
 	"github.com/li4n0/revsuit/pkg/ftp"
+	"github.com/li4n0/revsuit/pkg/ldap"
 	"github.com/li4n0/revsuit/pkg/mysql"
 	"github.com/li4n0/revsuit/pkg/rhttp"
 	"github.com/li4n0/revsuit/pkg/rmi"
@@ -69,6 +70,8 @@ func (revsuit *Revsuit) registerHttpRouter() {
 	settingsGroup.POST("/updateDnsConfig", revsuit.updateDnsConfig)
 	settingsGroup.GET("/getRmiConfig", revsuit.getRmiConfig)
 	settingsGroup.POST("/updateRmiConfig", revsuit.updateRmiConfig)
+	settingsGroup.GET("/getLdapConfig", revsuit.getLdapConfig)
+	settingsGroup.POST("/updateLdapConfig", revsuit.updateLdapConfig)
 	settingsGroup.GET("/getMySQLConfig", revsuit.getMySQLConfig)
 	settingsGroup.POST("/updateMySQLConfig", revsuit.updateMySQLConfig)
 	settingsGroup.GET("/getFtpConfig", revsuit.getFtpConfig)
@@ -95,6 +98,10 @@ func (revsuit *Revsuit) registerHttpRouter() {
 	rmiGroup.GET("", rmi.Records)
 	rmiGroup.DELETE("", rmi.Records)
 
+	ldapGroup := recordGroup.Group("/ldap")
+	ldapGroup.GET("", ldap.Records)
+	ldapGroup.DELETE("", ldap.Records)
+
 	ftpGroup := recordGroup.Group("/ftp")
 	ftpGroup.GET("", ftp.Records)
 	ftpGroup.DELETE("", ftp.Records)
@@ -122,6 +129,11 @@ func (revsuit *Revsuit) registerHttpRouter() {
 	rmiGroup.POST("", rmi.UpsertRules)
 	rmiGroup.DELETE("", rmi.DeleteRules)
 
+	ldapGroup = ruleGroup.Group("/ldap")
+	ldapGroup.GET("", ldap.ListRules)
+	ldapGroup.POST("", ldap.UpsertRules)
+	ldapGroup.DELETE("", ldap.DeleteRules)
+
 	ftpGroup = ruleGroup.Group("/ftp")
 	ftpGroup.GET("", ftp.ListRules)
 	ftpGroup.POST("", ftp.UpsertRules)

pkg/server/server.go

@@ -11,6 +11,7 @@ import (
 	"github.com/li4n0/revsuit/internal/record"
 	"github.com/li4n0/revsuit/pkg/dns"
 	"github.com/li4n0/revsuit/pkg/ftp"
+	"github.com/li4n0/revsuit/pkg/ldap"
 	"github.com/li4n0/revsuit/pkg/mysql"
 	http "github.com/li4n0/revsuit/pkg/rhttp"
 	"github.com/li4n0/revsuit/pkg/rmi"
@@ -28,6 +29,7 @@ type Revsuit struct {
 	dns   *dns.Server
 	mysql *mysql.Server
 	rmi   *rmi.Server
+	ldap  *ldap.Server
 	ftp   *ftp.Server
 
 	clients     map[int]*gin.Context
@@ -66,55 +68,35 @@ func initDatabase(dsn string) {
 		log.Fatal(err.Error())
 	}
 
-	err = database.DB.AutoMigrate(&http.Record{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&dns.Record{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&mysql.Record{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&http.Rule{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&dns.Rule{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&mysql.Rule{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&file.MySQLFile{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&rmi.Record{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&rmi.Rule{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&ftp.Record{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&ftp.Rule{})
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	err = database.DB.AutoMigrate(&file.FTPFile{})
+	err = database.DB.AutoMigrate(&http.Record{}, &http.Rule{})
 	if err != nil {
 		log.Fatal(err.Error())
 	}
 
+	err = database.DB.AutoMigrate(&dns.Record{}, &dns.Rule{})
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	err = database.DB.AutoMigrate(&mysql.Record{}, &mysql.Rule{}, &file.MySQLFile{})
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	err = database.DB.AutoMigrate(&rmi.Record{}, &rmi.Rule{})
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	err = database.DB.AutoMigrate(&ldap.Record{}, &ldap.Rule{})
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	err = database.DB.AutoMigrate(&ftp.Record{}, &ftp.Rule{}, &file.FTPFile{})
+	if err != nil {
+		log.Fatal(err.Error())
+	}
 }
 
 func initLog(level string) (logLevel log.Level) {
@@ -198,6 +180,9 @@ func New(c *Config) *Revsuit {
 	s.rmi = rmi.GetServer()
 	s.rmi.Config = c.RMI
 
+	s.ldap = ldap.GetServer()
+	s.ldap.Config = c.LDAP
+
 	s.ftp = ftp.GetServer()
 	s.ftp.Config = c.FTP
 
@@ -232,6 +217,9 @@ func (revsuit *Revsuit) Run() {
 	if revsuit.rmi != nil && revsuit.rmi.Enable {
 		go revsuit.rmi.Run()
 	}
+	if revsuit.ldap != nil && revsuit.ldap.Enable {
+		go revsuit.ldap.Run()
+	}
 	if revsuit.mysql != nil && revsuit.mysql.Enable {
 		go revsuit.mysql.Run()
 	}

pkg/server/settings.go

@@ -9,6 +9,7 @@ import (
 	"github.com/li4n0/revsuit/internal/database"
 	"github.com/li4n0/revsuit/pkg/dns"
 	"github.com/li4n0/revsuit/pkg/ftp"
+	"github.com/li4n0/revsuit/pkg/ldap"
 	"github.com/li4n0/revsuit/pkg/mysql"
 	"github.com/li4n0/revsuit/pkg/rhttp"
 	"github.com/li4n0/revsuit/pkg/rmi"
@@ -22,6 +23,7 @@ type Rules struct {
 	Dns   []dns.Rule
 	Mysql []mysql.Rule
 	Rmi   []rmi.Rule
+	Ldap  []ldap.Rule
 	Ftp   []ftp.Rule
 }
 
@@ -35,6 +37,7 @@ func exportRules(c *gin.Context) {
 	db.Model(&dns.Rule{}).Find(&rules.Dns)
 	db.Model(&mysql.Rule{}).Find(&rules.Mysql)
 	db.Model(&rmi.Rule{}).Find(&rules.Rmi)
+	db.Model(&rmi.Rule{}).Find(&rules.Ldap)
 	db.Model(&ftp.Rule{}).Find(&rules.Ftp)
 
 	out, err := yaml.Marshal(rules)
@@ -88,7 +91,7 @@ func (revsuit *Revsuit) importRules(c *gin.Context) {
 
 	for _, rule := range rules.Http {
 		if err := db.Model(&rhttp.Rule{}).Create(&rule).Error; err != nil {
-			errs = append(errs, errors.Wrap(err, fmt.Sprintf("http rule[%s]", rule.Name)).Error())
+			errs = append(errs, errors.Wrapf(err, "http rule[%s]", rule.Name).Error())
 			continue
 		}
 		count++
@@ -99,7 +102,7 @@ func (revsuit *Revsuit) importRules(c *gin.Context) {
 
 	for _, rule := range rules.Dns {
 		if err := db.Model(&dns.Rule{}).Create(&rule).Error; err != nil {
-			errs = append(errs, errors.Wrap(err, fmt.Sprintf("dns rule[%s]", rule.Name)).Error())
+			errs = append(errs, errors.Wrapf(err, "dns rule[%s]", rule.Name).Error())
 			continue
 		}
 		count++
@@ -110,7 +113,7 @@ func (revsuit *Revsuit) importRules(c *gin.Context) {
 
 	for _, rule := range rules.Mysql {
 		if err := db.Model(&mysql.Rule{}).Create(&rule).Error; err != nil {
-			errs = append(errs, errors.Wrap(err, fmt.Sprintf("mysql rule[%s]", rule.Name)).Error())
+			errs = append(errs, errors.Wrapf(err, "mysql rule[%s]", rule.Name).Error())
 			continue
 		}
 		count++
@@ -121,7 +124,7 @@ func (revsuit *Revsuit) importRules(c *gin.Context) {
 
 	for _, rule := range rules.Rmi {
 		if err := db.Model(&rmi.Rule{}).Create(&rule).Error; err != nil {
-			errs = append(errs, errors.Wrap(err, fmt.Sprintf("rmi rule[%s]", rule.Name)).Error())
+			errs = append(errs, errors.Wrapf(err, "rmi rule[%s]", rule.Name).Error())
 			continue
 		}
 		count++
@@ -130,9 +133,20 @@ func (revsuit *Revsuit) importRules(c *gin.Context) {
 		errs = append(errs, err.Error())
 	}
 
+	for _, rule := range rules.Ldap {
+		if err := db.Model(&ldap.Rule{}).Create(&rule).Error; err != nil {
+			errs = append(errs, errors.Wrapf(err, "ldap rule[%s]", rule.Name).Error())
+			continue
+		}
+		count++
+	}
+	if err := revsuit.ldap.UpdateRules(); err != nil {
+		errs = append(errs, err.Error())
+	}
+
 	for _, rule := range rules.Ftp {
 		if err := db.Model(&ftp.Rule{}).Create(&rule).Error; err != nil {
-			errs = append(errs, errors.Wrap(err, fmt.Sprintf("ftp rule[%s]", rule.Name)).Error())
+			errs = append(errs, errors.Wrapf(err, "ftp rule[%s]", rule.Name).Error())
 			continue
 		}
 		count++
@@ -381,6 +395,42 @@ func (revsuit *Revsuit) updateRmiConfig(c *gin.Context) {
 	}
 }
 
+func (revsuit *Revsuit) getLdapConfig(c *gin.Context) {
+	c.JSON(200, revsuit.ldap.Config)
+}
+
+func (revsuit *Revsuit) updateLdapConfig(c *gin.Context) {
+	var form = ldap.Config{}
+
+	if err := c.ShouldBindJSON(&form); err != nil {
+		c.JSON(400, gin.H{
+			"status": "failed",
+			"error":  err.Error(),
+			"data":   nil,
+		})
+		return
+	}
+
+	if form.Addr != revsuit.ldap.Addr {
+		revsuit.ldap.Addr = form.Addr
+		log.Info("Update ldap config [addr] to %s", form.Addr)
+	}
+
+	if form.Enable != revsuit.ldap.Enable {
+		log.Info("Update ldap config [enable] to %v", form.Enable)
+		if form.Enable {
+			go revsuit.ldap.Run()
+		} else {
+			revsuit.ldap.Stop()
+		}
+		return
+	}
+
+	if revsuit.ldap.Enable {
+		revsuit.ldap.Restart()
+	}
+}
+
 func (revsuit *Revsuit) getNoticeConfig(c *gin.Context) {
 	c.JSON(200, revsuit.config.Notice)
 }