added ldap

ldap.go

@@ -0,0 +1,10 @@
+package main
+
+import (
+	ldap "imuslab.com/arozos/mod/auth/ldap"
+)
+
+func ldapInit() {
+	ldapHandler := ldap.NewLdapHandler(authAgent, registerHandler, sysdb)
+	ldapHandler.SyncInformation()
+}

mod/auth/ldap/ldap.go

@@ -1,17 +1,17 @@
 package ldap
 
 import (
-	"fmt"
 	"log"
 
-	"github.com/go-ldap/ldap"
 	auth "imuslab.com/arozos/mod/auth"
+	"imuslab.com/arozos/mod/auth/ldap/ldapreader"
 	reg "imuslab.com/arozos/mod/auth/register"
 	db "imuslab.com/arozos/mod/database"
 )
 
 type ldapHandler struct {
-	ag *auth.AuthAgent
+	ag         *auth.AuthAgent
+	ldapreader *ldapreader.LdapReader
 }
 
 const (
@@ -19,77 +19,28 @@ const (
 	BindPassword = "12345678"
 	FQDN         = "192.168.1.147"
 	BaseDN       = "cn=users,dc=dsm"
-	Filter       = "(objectClass=*)"
 )
 
 //NewOauthHandler xxx
 func NewLdapHandler(authAgent *auth.AuthAgent, register *reg.RegisterHandler, coreDb *db.Database) *ldapHandler {
-	err := coreDb.NewTable("oauth")
+	log.Println("Starting LDAP server...")
+	err := coreDb.NewTable("ldap")
 	if err != nil {
 		log.Println("Failed to create oauth database. Terminating.")
 		panic(err)
 	}
 
-	NewlyCreatedOauthHandler := ldapHandler{
-		ag: authAgent,
+	LDAPHandler := ldapHandler{
+		ag:         authAgent,
+		ldapreader: ldapreader.NewLDAPReader(BindUsername, BindPassword, FQDN, BaseDN),
 	}
 
-	return &NewlyCreatedOauthHandler
+	return &LDAPHandler
 }
 
-func (handler *ldapHandler) Ldap() {
-	// Non-TLS Connection
-	l, err := handler.Connect()
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer l.Close()
-
-	// Normal Bind and Search
-	result, err := handler.BindAndSearch(l)
-	if err != nil {
-		log.Fatal(err)
-	}
-	for _, v := range result.Entries {
+func (handler *ldapHandler) SyncInformation() {
+	result, _ := handler.ldapreader.GetAllUser()
+	for _, v := range result {
 		v.PrettyPrint(4)
 	}
 }
-
-// Ldap Connection without TLS
-func (handler *ldapHandler) Connect() (*ldap.Conn, error) {
-	// You can also use IP instead of FQDN
-	l, err := ldap.DialURL(fmt.Sprintf("ldap://%s:389", FQDN))
-	if err != nil {
-		return nil, err
-	}
-
-	return l, nil
-}
-
-// Normal Bind and Search
-func (handler *ldapHandler) BindAndSearch(l *ldap.Conn) (*ldap.SearchResult, error) {
-	l.Bind(BindUsername, BindPassword)
-
-	searchReq := ldap.NewSearchRequest(
-		BaseDN,
-		//ldap.ScopeBaseObject, // you can also use ldap.ScopeWholeSubtree
-		ldap.ScopeWholeSubtree,
-		ldap.NeverDerefAliases,
-		0,
-		0,
-		false,
-		Filter,
-		[]string{"uid", "memberOf"},
-		nil,
-	)
-	result, err := l.Search(searchReq)
-	if err != nil {
-		return nil, fmt.Errorf("Search Error: %s", err)
-	}
-
-	if len(result.Entries) > 0 {
-		return result, nil
-	} else {
-		return nil, fmt.Errorf("Couldn't fetch search entries")
-	}
-}

mod/auth/ldap/ldapreader/reader.go

@@ -0,0 +1,66 @@
+package ldapreader
+
+import (
+	"fmt"
+
+	"github.com/go-ldap/ldap"
+)
+
+type LdapReader struct {
+	username string
+	password string
+	server   string
+	basedn   string
+}
+
+//NewOauthHandler xxx
+func NewLDAPReader(username string, password string, server string, basedn string) *LdapReader {
+
+	LDAPHandler := LdapReader{
+		username: username,
+		password: password,
+		server:   server,
+		basedn:   basedn,
+	}
+
+	return &LDAPHandler
+}
+
+func (handler *LdapReader) GetUser(username string) ([]*ldap.Entry, error) {
+	return handler.retrieveInformation("uid="+username+","+handler.basedn, "(objectClass=*)", ldap.ScopeBaseObject)
+}
+
+func (handler *LdapReader) GetAllUser() ([]*ldap.Entry, error) {
+	return handler.retrieveInformation(handler.basedn, "(objectClass=*)", ldap.ScopeWholeSubtree)
+}
+
+func (handler *LdapReader) retrieveInformation(dn string, filter string, typeOfSearch int) ([]*ldap.Entry, error) {
+	ldapURL, err := ldap.DialURL(fmt.Sprintf("ldap://%s:389", handler.server))
+	if err != nil {
+		return nil, err
+	}
+	defer ldapURL.Close()
+
+	ldapURL.Bind(handler.username, handler.password)
+	searchReq := ldap.NewSearchRequest(
+		dn,
+		typeOfSearch,
+		ldap.NeverDerefAliases,
+		0,
+		0,
+		false,
+		filter,
+		[]string{"uid", "memberOf"},
+		nil,
+	)
+	result, err := ldapURL.Search(searchReq)
+	if err != nil {
+		return nil, fmt.Errorf("Search Error: %s", err)
+	}
+
+	if len(result.Entries) > 0 {
+		return result.Entries, nil
+	} else {
+		return nil, fmt.Errorf("Couldn't fetch search entries")
+	}
+}

startup.go

@@ -43,6 +43,7 @@ func RunStartup() {
 	permissionInit()        //Register permission interface after user
 	RegisterSystemInit()    //See register.go
 	OAuthInit()             //Oauth system init
+	ldapInit()              //LDAP system init
 	GroupStoragePoolInit()  //Register permission groups's storage pool, require permissionInit()
 	BridgeStoragePoolInit() //Register the bridged storage pool based on mounted storage pools