Exemple #1
0
func (_s *LDAP) InitS(rLog SBMSystem.LogFile, user, password, server string) int {
	var err error

	_s.CS = -1

	rLog.LogDbg(2, "LDAP Init SRV ***** Trying connect to server ", server, " with login ", user)

	_s.D, err = ldap.Dial("tcp", server)
	if err != nil {
		rLog.LogDbg(0, "LDAP::Dial() to server ", server, " error: ", err)
		return -1
	}

	//L.Debug()

	err = _s.D.Bind(user, password)
	if err != nil {
		rLog.LogDbg(1, "LDAP::Bind() to server ", server, " with login ", user, " error: ", err)
		return -1
	}

	rLog.LogDbg(2, "LDAP Init SRV ***** Success! Connected to server ", server, " with login ", user)

	_s.CS = 0
	return 0
}
Exemple #2
0
func (_s *LDAP) _getBaseDN(rLog SBMSystem.LogFile, search, basedn string) string {
	var uattr = []string{"dn"}

	lsearch := ldap.NewSearchRequest(basedn, 2, ldap.NeverDerefAliases, 0, 0, false, search, uattr, nil)
	sr, err := _s.D.Search(lsearch)
	if err != nil {
		rLog.LogDbg(0, "LDAP::Search() ", basedn, " error: ", err)
	}

	if len(sr.Entries) > 0 {
		for _, entry := range sr.Entries {
			return entry.DN
		}
	}
	return ""
}
Exemple #3
0
func (_s *LDAP) _checkGroupMember(rLog SBMSystem.LogFile, userDN, groupDN, baseDN string, recurse_count int) int {
	var (
		uattr  = []string{"memberOf"}
		result = int(-1)
	)

	if userDN == "" || groupDN == "" {
		return -1
	}

	if recurse_count <= 0 {
		return -1
	}

	lsearch := ldap.NewSearchRequest(userDN, 0, ldap.NeverDerefAliases, 0, 0, false, "(objectclass=*)", uattr, nil)
	sr, err := _s.D.Search(lsearch)
	if err != nil {
		rLog.LogDbg(0, "LDAP::Search() ", userDN, " error: ", err)
	}

	if len(sr.Entries) > 0 {
		for _, entry := range sr.Entries {
			for _, attr := range entry.Attributes {
				if attr.Name == "memberOf" {
					for _, x := range attr.Values {
						if groupDN == x {
							return 0
						} else {
							if x != userDN {
								result = _s._checkGroupMember(rLog, x, groupDN, baseDN, recurse_count-1)
								if result == 0 {
									return 0
								}
							}
						}
					}
				}
			}
		}
	}
	return -1
}
Exemple #4
0
func (_s *LDAP) CheckGroupMember(rLog SBMSystem.LogFile, user, group, baseDN string) int {
	const (
		recurs_count = 10
	)

	rLog.LogDbg(2, "LDAP CheckGroupMember...")

	userDN := _s._getBaseDN(rLog, user, baseDN)
	groupDN := _s._getBaseDN(rLog, group, baseDN)

	if userDN == "" || groupDN == "" {
		return -1
	}

	if _s._checkGroupMember(rLog, userDN, groupDN, baseDN, 1) == 0 {
		return 0
	} else {
		return _s._checkGroupMember(rLog, userDN, groupDN, baseDN, recurs_count)
	}

	return -1
}
Exemple #5
0
func (_s *LDAP) Init(conf SBMSystem.ReadJSONConfig, rLog SBMSystem.LogFile) int {
	var (
		attemptCounter = int(0)
		err            error
	)

	_s.CS = -1

	for {
		if attemptCounter > len(conf.Conf.LDAP_URL)*2 {
			rLog.LogDbg(0, "LDAP Init SRV ***** Error connect to all LDAP servers !!!")
			return -1
		}

		if LDAPCounter > len(conf.Conf.LDAP_URL)-1 {
			LDAPCounter = 0
		}

		rLog.LogDbg(2, "LDAP Init SRV ***** Trying connect to server ", LDAPCounter+1, " of ", len(conf.Conf.LDAP_URL), ": ", conf.Conf.LDAP_URL[LDAPCounter][0])
		_s.D, err = ldap.Dial("tcp", conf.Conf.LDAP_URL[LDAPCounter][0])
		if err != nil {
			LDAPCounter++
			attemptCounter++
			continue
		}

		rLog.LogDbg(2, "LDAP Init SRV ***** Success! Connected to server ", LDAPCounter+1, " of ", len(conf.Conf.LDAP_URL), ": ", conf.Conf.LDAP_URL[LDAPCounter][0])
		LDAPCounter++
		break
	}

	//_s.D.Debug()

	err = _s.D.Bind(conf.Conf.LDAP_URL[0][1], conf.Conf.LDAP_URL[0][2])
	if err != nil {
		rLog.LogDbg(0, "LDAP::Bind() to server ", conf.Conf.LDAP_URL[LDAPCounter][0], " with login ", conf.Conf.LDAP_URL[0][1], " error: ", err)
		return -1
	}

	_s.CS = 0
	return 0
}
func main() {
	var (
		jsonConfig SBMSystem.ReadJSONConfig
		rLog       SBMSystem.LogFile
		pg         SBMConnect.PgSQL
	)

	const (
		pName = string("SABook CardDAVMaker Poller")
		pVer  = string("5 2015.11.25.21.00")
	)

	jsonConfig.Init("./CardDAVMaker.log", "./CardDAVMaker.json")

	rLog.ON(jsonConfig)

	if pg.Init(jsonConfig, "insert into aaa_dav_ntu values (0,123);") != 0 {
		rLog.Log("POLLER: Poll insert error!")
	}
	defer pg.Close()

	rLog.OFF()

}
func goNTUWork(conf SBMSystem.ReadJSONConfig, rLog SBMSystem.LogFile) {

	type usIDPartList struct {
		id   int
		name string
	}

	var (
		ldap_Attr   []string
		ldap_VCard  []string
		queryx      string
		multiInsert = int(64)
		//idxUsers    = int(1)
		idxCards = int(1)
		workMode = string("FULL")
		i        int
		pg       SBMConnect.PgSQL
		my       SBMConnect.MySQL
		ld       SBMConnect.LDAP
		err      error
		pgrows1  *sql.Rows
	)

	rLog.Log("--> WakeUP!")

	for i = 0; i < len(conf.Conf.WLB_LDAP_ATTR); i++ {
		ldap_Attr = append(ldap_Attr, conf.Conf.WLB_LDAP_ATTR[i][0])
		ldap_VCard = append(ldap_VCard, conf.Conf.WLB_LDAP_ATTR[i][1])
	}

	if pg.Init(conf, "") < 0 {
		log.Println("Init PgSQL Error!")
		return
	}
	defer pg.Close()

	if my.Init(conf, mySQL_InitDB) < 0 {
		log.Println("Init MySQL Error!")
		return
	}
	defer my.Close()

	if ld.Init(conf) < 0 {
		log.Println("Init LDAP Error!")
		return
	}
	defer ld.Close()

	time.Sleep(10 * time.Second)

	x := make(map[string]string, len(ldap_Attr))

	multiCount := 0
	rLog.Log("\tCreate cacheDB from LDAP...")

	time_now := time.Now().Unix()
	time_get := pg.QSimple("select updtime from aaa_dav_ntu where userid=0;")

	switch {
	case time_get < 0:
		log.Println("PgSQL: Error reading NTU table")
		return
	case time_get > 0:
		pgrows1, err = pg.D.Query("select x.id, x.login, x.password, x.cdavprefix from aaa_logins as x where x.id in (select userid from aaa_dns where userid=x.id) order by login;")
		if err != nil {
			log.Printf("PG::Query() 02 error: %v\n", err)
			return
		}
		workMode = "FULL"
	case time_get == 0:
		pgrows1, err = pg.D.Query("select x.id, x.login, x.password, x.cdavprefix from aaa_logins as x, aaa_dav_ntu as y where x.id=y.userid and x.id in (select userid from aaa_dns where userid=x.id) order by login;")
		if err != nil {
			log.Printf("PG::Query() 03 error: %v\n", err)
			return
		}
		workMode = "PART"
	}

	usID := 0
	usName := ""
	usPass := ""
	usCDavPrefix := 0
	//userIDGet := 0
	usIDArray := make([]usIDPartList, 0)
	for pgrows1.Next() {
		usCDavPrefix = 0
		pgrows1.Scan(&usID, &usName, &usPass, &usCDavPrefix)
		usIDArray = append(usIDArray, usIDPartList{id: usID, name: usName})
		/*
			userIDGet = my.QSimple("select id from users where username='******';")
			switch {
			case userIDGet < 0:
				log.Println("Error get user ID")
				return
			case userIDGet > 0:
				idxUsers = userIDGet
			case userIDGet == 0:
				userIDGet = my.QSimple("select id from users order by id desc limit 1;")
				if userIDGet > 0 {
					userIDGet++
					idxUsers = userIDGet
				} else {
					userIDGet = 0
					userIDGet++
					log.Println("Error get max user ID")
					//return
				}
			}
		*/
		queryx = fmt.Sprintf("INSERT INTO z_cache_users (id, username, digesta1)\n\tVALUES (%d, '%s', '%s');", usID, usName, usPass)
		queryx = fmt.Sprintf("%s\nINSERT INTO z_cache_principals (id, uri, email, displayname, vcardurl)\n\tVALUES (%d, 'principals/%s', NULL, NULL, NULL);", queryx, usID, usName)
		queryx = fmt.Sprintf("%s\nINSERT INTO z_cache_addressbooks (id, principaluri, uri, ctag)\n\tVALUES (%d, 'principals/%s', 'default', 1); select id from users order by id desc limit 1", queryx, usID, usName)
		//log.Printf("%s\n", queryx)
		_, err = my.D.Query(queryx)
		if err != nil {
			log.Printf("03 MySQL::Query() error: %v\n", err)
			log.Printf("%s\n", queryx)
			return
		}

		pgrows2, err := pg.D.Query(fmt.Sprintf("select dn from aaa_dns where userid=%d;", usID))
		if err != nil {
			log.Printf("02 PG::Query() error: %v\n", err)
			return
		}

		usDN := ""
		for pgrows2.Next() {
			pgrows2.Scan(&usDN)
			log.Printf("\t\t\t%3d/%s - %s\n", usID, usName, usDN)

			search := ldap.NewSearchRequest(usDN, 2, ldap.NeverDerefAliases, 0, 0, false, conf.Conf.LDAP_URL[0][4], ldap_Attr, nil)

			sr, err := ld.D.Search(search)
			if err != nil {
				log.Printf("LDAP::Search() error: %v\n", err)
				return
			}

			queryx = ""
			if len(sr.Entries) > 0 {
				for _, entry := range sr.Entries {
					for k := 0; k < len(ldap_Attr); k++ {
						x[ldap_VCard[k]] = ""
					}
					for _, attr := range entry.Attributes {
						for k := 0; k < len(ldap_Attr); k++ {
							if attr.Name == ldap_Attr[k] {
								x[ldap_VCard[k]] = strings.Join(attr.Values, ",")
								x[ldap_VCard[k]] = strings.Replace(x[ldap_VCard[k]], ",", "\n"+ldap_VCard[k]+":", -1)
							}
						}
					}
					y := fmt.Sprintf("BEGIN:VCARD\n")
					for k := 0; k < len(ldap_Attr); k++ {
						if x[ldap_VCard[k]] != "" {
							if ldap_VCard[k] == "FN" {
								fn_split := strings.Split(x[ldap_VCard[k]], " ")
								fn_nofam := strings.Replace(x[ldap_VCard[k]], fn_split[0], "", -1)
								fn_nofam = strings.Trim(fn_nofam, " ")
								y = fmt.Sprintf("%s%s:%s %s\n", y, ldap_VCard[k], fn_nofam, fn_split[0])
							} else {
								switch usCDavPrefix {
								case 2:
									if ldap_VCard[k] == conf.Conf.CardDAVIPSuffix[0] {
										y = fmt.Sprintf("%s%s:%s@%s\n", y, ldap_VCard[k], x[ldap_VCard[k]], conf.Conf.CardDAVIPSuffix[1])
									}
									y = fmt.Sprintf("%s%s:%s\n", y, ldap_VCard[k], x[ldap_VCard[k]])
								case 1:
									if ldap_VCard[k] == conf.Conf.CardDAVIPSuffix[0] {
										y = fmt.Sprintf("%s%s:%s@%s\n", y, ldap_VCard[k], x[ldap_VCard[k]], conf.Conf.CardDAVIPSuffix[1])
									} else {
										y = fmt.Sprintf("%s%s:%s\n", y, ldap_VCard[k], x[ldap_VCard[k]])
									}
								default:
									y = fmt.Sprintf("%s%s:%s\n", y, ldap_VCard[k], x[ldap_VCard[k]])
								}

							}
						}
					}
					z := md5.New()
					z.Write([]byte(y))
					uid := hex.EncodeToString(z.Sum(nil))
					y = fmt.Sprintf("%sUID:%s\n", y, uid)
					y = fmt.Sprintf("%sEND:VCARD\n", y)
					queryx = fmt.Sprintf("%s\nINSERT INTO z_cache_cards (id, addressbookid, carddata, uri, lastmodified)\n\tVALUES (%d, %d, '%s', '%s.vcf', NULL);", queryx, idxCards, usID, y, uid)
					if multiCount > multiInsert {
						_, err = my.D.Query(queryx)
						if err != nil {
							log.Printf("MySQL::Query() error: %v\n", err)
							log.Printf("%s\n", queryx)
							return
						}
						queryx = ""
						multiCount = 0
					}
					multiCount++
					idxCards++

				}
			}
			_, err = my.D.Query(queryx)
			if err != nil {
				log.Printf("MySQL::Query() error: %v\n", err)
				log.Printf("%s\n", queryx)
				return
			}
			queryx = ""
			multiCount = 0
		}
		//idxUsers++
	}

	rLog.Log("\t\tComplete!")

	if workMode == "PART" {
		rLog.Log("\tUpdate tables in PartialUpdate mode...")
		for j := 0; j < len(usIDArray); j++ {
			log.Printf("\t\t\tUpdate %d/%s...\n", usIDArray[j].id, usIDArray[j].name)
			for i := 0; i < len(mySQL_Update_part1); i++ {
				log.Printf("\t\t\tstep %d (%d of %d)...\n", j+1, i+1, len(mySQL_Update_part1))
				if my.QSimple(strings.Replace(mySQL_Update_part1[i], "XYZIDXYZ", fmt.Sprintf("%d", usIDArray[j].id), -1)) < 0 {
					log.Println("MySQL: Update error")
					return
				}
				time.Sleep(2 * time.Second)
			}
			for i := 0; i < len(mySQL_Update1); i++ {
				log.Printf("\t\t\tstep %d (%d of %d)...\n", j+1, i+1, len(mySQL_Update1))

				if my.QSimple(mySQL_Update1[i]) < 0 {
					log.Println("MySQL: Update error")
					return
				}
				time.Sleep(2 * time.Second)
			}
			for i := 0; i < len(mySQL_Update_part2); i++ {
				log.Printf("\t\t\tstep %d (%d of %d)...\n", j+1, i+1, len(mySQL_Update_part2))
				if my.QSimple(strings.Replace(mySQL_Update_part2[i], "XYZIDXYZ", fmt.Sprintf("%d", usIDArray[j].id), -1)) < 0 {
					log.Println("MySQL: Update error")
					return
				}
				time.Sleep(2 * time.Second)
			}
			for i := 0; i < len(mySQL_Update2); i++ {
				log.Printf("\t\t\tstep %d (%d of %d)...\n", j+1, i+1, len(mySQL_Update2))
				if my.QSimple(mySQL_Update2[i]) < 0 {
					log.Println("MySQL: Update error")
					return
				}
				time.Sleep(2 * time.Second)
			}
			time.Sleep(2 * time.Second)
		}
	} else {
		rLog.Log("\tUpdate tables...")
		for i := 0; i < len(mySQL_Update_full1); i++ {
			log.Printf("\t\t\tstep %d of %d...\n", i+1, len(mySQL_Update_full1))
			if my.QSimple(mySQL_Update_full1[i]) < 0 {
				log.Println("MySQL: Update error")
				return
			}
			time.Sleep(2 * time.Second)
		}
		for i := 0; i < len(mySQL_Update1); i++ {
			log.Printf("\t\t\tstep %d of %d...\n", i+1, len(mySQL_Update1))
			if my.QSimple(mySQL_Update1[i]) < 0 {
				log.Println("MySQL: Update error")
				return
			}
			time.Sleep(2 * time.Second)
		}
		for i := 0; i < len(mySQL_Update_full2); i++ {
			log.Printf("\t\t\tstep %d of %d...\n", i+1, len(mySQL_Update_full2))
			if my.QSimple(mySQL_Update_full2[i]) < 0 {
				log.Println("MySQL: Update error")
				return
			}
			time.Sleep(2 * time.Second)
		}
		for i := 0; i < len(mySQL_Update2); i++ {
			log.Printf("\t\t\tstep %d of %d...\n", i+1, len(mySQL_Update2))
			if my.QSimple(mySQL_Update2[i]) < 0 {
				log.Println("MySQL: Update error")
				return
			}
			time.Sleep(2 * time.Second)
		}
	}

	rLog.Log("\t\tComplete!")

	rLog.Log("\tClean NeedToUpdate table...")

	if pg.QSimple("delete from aaa_dav_ntu where userid=0 or updtime<", time_now, ";") < 0 {
		log.Println("PgSQL: Clean NTU table error")
		return
	}

	rLog.Log("\tComplete!")
	rLog.Bye()
}
func main() {
	var (
		jsonConfig SBMSystem.ReadJSONConfig
		rLog       SBMSystem.LogFile
		pid        SBMSystem.PidFile
		sleepWatch = int(0)
	)

	const (
		pName = string("SABook CardDAVMaker")
		pVer  = string("5 2015.11.25.21.00")
	)

	fmt.Printf("\n\t%s V%s\n\n", pName, pVer)

	jsonConfig.Init("./CardDAVMaker.log", "./CardDAVMaker.json")

	rLog.ON(jsonConfig)
	pid.ON(jsonConfig)
	pid.OFF(jsonConfig)
	rLog.OFF()

	SBMSystem.Fork(jsonConfig)
	SBMSystem.Signal(jsonConfig, pid)

	rLog.ON(jsonConfig)
	pid.ON(jsonConfig)
	defer pid.OFF(jsonConfig)
	rLog.Hello(pName, pVer)
	rLog.OFF()

	for {
		rLog.ON(jsonConfig)
		jsonConfig.Update()

		if checkNTUWishes(jsonConfig, rLog) > 0 {
			rLog.Hello(pName, pVer)
			goNTUWork(jsonConfig, rLog)
			sleepWatch = 0
		}

		if sleepWatch > 3600 {
			rLog.Log("<-- I'm alive ... :)")
			sleepWatch = 0
		}

		rLog.OFF()
		time.Sleep(time.Duration(jsonConfig.Conf.Sleep_Time) * time.Second)
		sleepWatch += jsonConfig.Conf.Sleep_Time
	}
}