openidec

db.go (27342B)

---

 // Database functions.
 // Database is the file with line-bundles: msgid:base64 encoded msg.
 // File db.idx is created and mantained automatically.
 // There is also points.txt, db of users.
 package ii
 
 import (
 	"bufio"
 	"crypto/sha256"
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"regexp"
 	"sort"
 	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 	"golang.org/x/crypto/bcrypt"
 )
 
 // This is index entry. Information about message that is loaded in memory.
 // So, the index could not be very huge.
 // Num: sequence number.
 // Id: MsgId
 // Echo: Echoarea
 // To, From, Repto: message attributes
 // Off: offset to bundle-line in database (in bytes)
 type MsgInfo struct {
 	Num   int
 	Id    string
 	Echo  string
 	To    string
 	Off   int64
 	Repto string
 	From  string
 	Topic string
 }
 
 // Index object. Holds List and Hash for all MsgInfo entries
 // FileSize is used to auto reread new entries if it has changed by
 // someone.
 type Index struct {
 	Hash     map[string]*MsgInfo
 	List     []string
 	FileSize int64
 }
 
 // Database object. Returns by OpenDB.
 // Idx: Index structure (like dictionary).
 // Name: database name, 'db' by default.
 // Sync: used to syncronize access to DB from goroutines (many readers, one writer).
 // IdxSync: same, but for Index.
 // LockDepth: used for recursive file lock, to avoid conflict between idecctl and idecd.
 type DB struct {
 	Path      string
 	Idx       Index
 	Sync      sync.RWMutex
 	IdxSync   sync.RWMutex
 	Name      string
 	LockDepth int32
 }
 
 // Utility function. Just append line (text) to file (fn)
 func append_file(fn string, text string) error {
 	f, err := os.OpenFile(fn, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
 		return err
 	}
 	defer f.Close()
 	if _, err := f.WriteString(text + "\n"); err != nil {
 		return err
 	}
 	return nil
 }
 
 // Recursive file lock. Used to avoid conflicts between idecctl and idecd.
 // Uses mkdir as atomic operation.
 // Note: dirs created as db.LockPath()
 // 16 sec is limit.
 func (db *DB) Lock() bool {
 	if atomic.AddInt32(&db.LockDepth, 1) > 1 {
 		return true
 	}
 	try := 16
 	for try > 0 {
 		if err := os.Mkdir(db.LockPath(), 0777); err == nil {
 			return true
 		}
 		time.Sleep(time.Second)
 		try -= 1
 	}
 	Error.Printf("Can not acquire lock for 16 seconds: %s", db.LockPath())
 	return false
 }
 
 // Recursive file lock: unlock
 // See Lock comment.
 func (db *DB) Unlock() {
 	if atomic.AddInt32(&db.LockDepth, -1) > 0 {
 		return
 	}
 	os.Remove(db.LockPath())
 }
 
 // Returns path to index file.
 func (db *DB) IndexPath() string {
 	return fmt.Sprintf("%s.idx", db.Path)
 }
 
 // Return path to database itself
 func (db *DB) BundlePath() string {
 	return db.Path
 }
 
 // Returns path to lock.
 func (db *DB) LockPath() string {
 	pat := strings.Replace(db.Path, "/", "_", -1)
 	return fmt.Sprintf("%s/%s-bundle.lock", os.TempDir(), pat)
 }
 
 // var MaxMsgLen int = 128 * 1024 * 1024
 
 // This function creates index. It locks.
 func (db *DB) CreateIndex() error {
 	db.Sync.Lock()
 	defer db.Sync.Unlock()
 	db.Lock()
 	defer db.Unlock()
 
 	return db._CreateIndex()
 }
 
 // Utility to pass all lines of file (path) to fn(line).
 // Stops on EOF or fn returns false.
 func FileLines(path string, fn func(string) bool) error {
 	f, err := os.Open(path)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil
 		}
 		return err
 	}
 	defer f.Close()
 	return f_lines(f, fn)
 }
 
 // Internal function to implement FileLines. Works with
 // file by *File object.
 func f_lines(f *os.File, fn func(string) bool) error {
 	reader := bufio.NewReader(f)
 	for {
 		line, err := reader.ReadString('\n')
 		if err != nil && err != io.EOF {
 			return err
 		}
 		line = strings.TrimSuffix(line, "\n")
 		if err == io.EOF {
 			break
 		}
 		if !fn(line) {
 			break
 		}
 	}
 	// scanner := bufio.NewScanner(f)
 	// scanner.Buffer(make([]byte, MaxMsgLen), MaxMsgLen)
 
 	// for scanner.Scan() {
 	// 	line := scanner.Text()
 	// 	if !fn(line) {
 	// 		break
 	// 	}
 	// }
 	return nil
 }
 
 // Internal function of CreateIndex.
 // Does not lock!
 func (db *DB) _CreateIndex() error {
 	fidx, err := os.OpenFile(db.IndexPath(), os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
 		return err
 	}
 	defer fidx.Close()
 	var off int64
 	return FileLines(db.BundlePath(), func(line string) bool {
 		msg, _ := DecodeBundle(line)
 		if msg == nil {
 			off += int64(len(line) + 1)
 			return true
 		}
 		repto, _ := msg.Tag("repto")
 		ioff := off
 		if v, _ := msg.Tag("access"); v == "blacklist" {
 			ioff = -1
 		}
 
 		_, err := fidx.WriteString(fmt.Sprintf("%s:%s:%d:%s:%s:%s\n",
 			msg.MsgId, msg.Echo, ioff, msg.To, msg.From, repto))
 		if err != nil {
 			// FIXME: handle this error
 			panic(err)
 		}
 		off += int64(len(line) + 1)
 		return true
 	})
 }
 
 // Internal function. Create and open new index.
 func (db *DB) _ReopenIndex() (*os.File, error) {
 	err := db._CreateIndex()
 	if err != nil {
 		return nil, err
 	}
 	file, err := os.Open(db.IndexPath())
 	if err != nil {
 		return nil, err
 	}
 	return file, nil
 }
 
 // Loads index. If index doesent exists, create and load it.
 // If index was changed, reread tail.
 // This function does lock.
 func (db *DB) LoadIndex() error {
 	db.IdxSync.Lock()
 	defer db.IdxSync.Unlock()
 	var Idx Index
 	file, err := os.Open(db.IndexPath())
 	if err != nil {
 		db.Idx = Idx
 		if os.IsNotExist(err) {
 			file, err = db._ReopenIndex()
 			if err != nil {
 				Error.Printf("Can not seek to end of index")
 				return err
 			}
 		} else {
 			Error.Printf("Can not open index: %s", err)
 			return err
 		}
 	}
 	defer file.Close()
 
 	info, err := file.Stat()
 	if err != nil {
 		Error.Printf("Can not stat index: %s", err)
 		return err
 	}
 	fsize := info.Size()
 
 	if db.Idx.Hash != nil { // already loaded
 		if fsize > db.Idx.FileSize {
 			Trace.Printf("Refreshing index file...%d>%d", fsize, db.Idx.FileSize)
 			if _, err := file.Seek(db.Idx.FileSize, 0); err != nil {
 				Error.Printf("Can not seek index: %s", err)
 				return err
 			}
 			Idx = db.Idx
 			// rebuild topics
 			for _, v := range Idx.Hash {
 				v.Topic = ""
 			}
 		} else if info.Size() < db.Idx.FileSize {
 			Info.Printf("Index file truncated, rebuild inndex...")
 			file, err = db._ReopenIndex()
 			if err != nil {
 				Error.Printf("Can not reopen index: %s", err)
 				return err
 			}
 			defer file.Close()
 		} else {
 			return nil
 		}
 	} else {
 		Idx.Hash = make(map[string]*MsgInfo)
 	}
 	var err2 error
 	linenr := 0
 	nr := len(Idx.List)
 	err = f_lines(file, func(line string) bool {
 		linenr++
 		info := strings.Split(line, ":")
 		if len(info) < 6 {
 			err2 = errors.New("Wrong format on line:" + fmt.Sprintf("%d", linenr))
 			return false
 		}
 		mi := MsgInfo{Num: nr, Id: info[0], Echo: info[1], To: info[3], From: info[4]}
 		if _, err := fmt.Sscanf(info[2], "%d", &mi.Off); err != nil {
 			err2 = errors.New("Wrong offset on line: " + fmt.Sprintf("%d", linenr))
 			return false
 		}
 		mi.Repto = info[5]
 		if mm, ok := Idx.Hash[mi.Id]; !ok { // new msg
 			Idx.List = append(Idx.List, mi.Id)
 			nr++
 		} else {
 			mi.Num = mm.Num
 		}
 		Idx.Hash[mi.Id] = &mi
 		// Trace.Printf("Adding %s to index", mi.Id)
 		return true
 	})
 	if err != nil {
 		Error.Printf("Can not parse index: %s", err)
 		return err
 	}
 	if err2 != nil {
 		Error.Printf("Can not parse index: %s", err2)
 		return err2
 	}
 	Idx.FileSize = fsize
 	db.Idx = Idx
 	return nil
 }
 
 // Internal function to Lookup message in loaded index.
 // If idx parameter is true, load and created index.
 // Returns MsgInfo pointer or nil if fails.
 // Does lock!
 // bl: look in blacklisted messages too?
 func (db *DB) _Lookup(Id string, bl bool, idx bool) *MsgInfo {
 	if idx {
 		if err := db.LoadIndex(); err != nil {
 			return nil
 		}
 	}
 	db.IdxSync.RLock()
 	defer db.IdxSync.RUnlock()
 	info, ok := db.Idx.Hash[Id]
 	if !ok || (!bl && info.Off < 0) {
 		return nil
 	}
 	return info
 }
 
 // Lookup variant, but without locking.
 // Useful if caller do locking logic himself.
 func (db *DB) LookupFast(Id string, bl bool) *MsgInfo {
 	if Id == "" {
 		return nil
 	}
 	return db._Lookup(Id, bl, false)
 }
 
 // Lookup message in index.
 // Do not search blacklisted messages.
 // Creates/load index if needed.
 // Returns MsgInfo pointer.
 // Does lock!
 func (db *DB) Lookup(Id string) *MsgInfo {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	db.Lock()
 	defer db.Unlock()
 
 	return db._Lookup(Id, false, true)
 }
 
 // Same as Lookup, but checks in blacklisted messages too
 func (db *DB) Exists(Id string) *MsgInfo {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	db.Lock()
 	defer db.Unlock()
 
 	return db._Lookup(Id, true, true)
 }
 
 // Lookup messages in index.
 // Gets: slice of message ids to get.
 // Returns slice of MsgInfo pointers.
 // Does lock!
 func (db *DB) LookupIDS(Ids []string) []*MsgInfo {
 	var info []*MsgInfo
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	db.Lock()
 	defer db.Unlock()
 	for _, id := range Ids {
 		i := db._Lookup(id, false, true)
 		if i != nil {
 			info = append(info, i)
 		}
 	}
 	return info
 }
 
 // Internal function. Gets bundle by message id.
 // If idx is true: load/create index.
 // Returns: msgid:base64 bundle.
 // Does not lock!
 func (db *DB) _GetBundle(Id string, idx bool) (string, *MsgInfo) {
 	info := db._Lookup(Id, false, idx)
 	if info == nil {
 		Info.Printf("Can not find bundle: %s\n", Id)
 		return "", nil
 	}
 	f, err := os.Open(db.BundlePath())
 	if err != nil {
 		Error.Printf("Can not open DB: %s\n", err)
 		return "", nil
 	}
 	defer f.Close()
 	_, err = f.Seek(info.Off, 0)
 	if err != nil {
 		Error.Printf("Can not seek DB: %s\n", err)
 		return "", nil
 	}
 	var bundle string
 	err = f_lines(f, func(line string) bool {
 		bundle = line
 		return false
 	})
 	if err != nil {
 		Error.Printf("Can not get %s from DB: %s\n", Id, err)
 		return "", nil
 	}
 	return bundle, info
 }
 
 // Get bundle line by message id from db.
 // Does lock!
 // Loads/create index if needed.
 func (db *DB) GetBundle(Id string) string {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	db.Lock()
 	defer db.Unlock()
 
 	b, _ := db._GetBundle(Id, true)
 	return b
 }
 
 func (db *DB) GetBundleInfo(Id string) (string, *MsgInfo) {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	db.Lock()
 	defer db.Unlock()
 
 	return db._GetBundle(Id, true)
 }
 
 // Get decoded message from db by message id.
 // Does lock. Loads/create index if needed.
 func (db *DB) Get(Id string) *Msg {
 	bundle := db.GetBundle(Id)
 	if bundle == "" {
 		return nil
 	}
 	m, err := DecodeBundle(bundle)
 	if err != nil {
 		Error.Printf("Can not decode bundle on get: %s\n", Id)
 	}
 	return m
 }
 
 // Fast varian (w/o locking) of Get.
 // Get decoded message from db by message id.
 // Does NOT lock! Loads/create index if needed.
 func (db *DB) GetFast(Id string) *Msg {
 	bundle, _ := db._GetBundle(Id, false)
 	if bundle == "" {
 		return nil
 	}
 	m, err := DecodeBundle(bundle)
 	if err != nil {
 		Error.Printf("Can not decode bundle on get: %s\n", Id)
 	}
 	return m
 }
 
 // Query used to make queries to Index
 // If some field of: Echo, Repto, From, To is not ""
 // fields will be matched with MsgInfo entry (logical AND).
 // If Match function is not nil, this function will be used for matching.
 // Blacklisted: search in blacklisted messages if true.
 // User: authorized access to private areas.
 // Start & Lim: slice of query. For example: -1, 1 -- get last message in db. 0, 1 -- first.
 type Query struct {
 	Echo        string
 	Repto       string
 	From        string
 	To          string
 	Start       int
 	Lim         int
 	Blacklisted bool
 	User        User
 	Match       func(mi *MsgInfo, q Query) bool
 }
 
 // utility function to add string in front of slice
 func prependStr(x []string, y string) []string {
 	x = append(x, "")
 	copy(x[1:], x)
 	x[0] = y
 	return x
 }
 
 // Check if message is private
 func (db *DB) Access(info *MsgInfo, user *User) bool {
 	if IsPrivate(info.Echo) {
 		if user.Name == "" {
 			return false
 		}
 		if info.To != "All" && info.From != user.Name && info.To != user.Name {
 			return false
 		}
 	}
 	return true
 }
 
 // Default match function for queries.
 func (db *DB) Match(info *MsgInfo, r Query) bool {
 	if r.Blacklisted {
 		if info.Off >= 0 {
 			return false
 		}
 	} else if info.Off < 0 {
 		return false
 	}
 	if r.Echo != "" && r.Echo != info.Echo {
 		return false
 	}
 	if r.Repto == "!" {
 		if info.Repto != "" {
 			return false
 		}
 	} else if r.Repto != "" && r.Repto != info.Repto {
 		return false
 	}
 	if r.To != "" && r.To != info.To {
 		return false
 	}
 	if r.From != "" && r.From != info.From {
 		return false
 	}
 	if !db.Access(info, &r.User) {
 		return false
 	}
 	if r.Match != nil {
 		return r.Match(info, r)
 	}
 	return true
 }
 
 // Used to get information about echoarea
 // Count: number of messages
 // Topics: number of topics
 // Last: last MsgInfo
 // Msg: last message pointer
 type Echo struct {
 	Name   string
 	Count  int
 	Topics int
 	Last   *MsgInfo
 	Msg    *Msg
 }
 
 // Make query and select Echoes
 // Returns: slice of pointers to Echo.
 // names: if not empty, lookup only in theese echoareas
 // Does lock.
 // Load/create index if needed.
 // Echoes sorted by date of last messages.
 func (db *DB) Echoes(names []string, q Query) []*Echo {
 	db.Sync.Lock()
 	defer db.Sync.Unlock()
 	db.Lock()
 	defer db.Unlock()
 	var list []*Echo
 
 	filter := make(map[string]bool)
 	for _, n := range names {
 		filter[n] = true
 	}
 
 	if err := db.LoadIndex(); err != nil {
 		return list
 	}
 
 	db.IdxSync.RLock()
 	defer db.IdxSync.RUnlock()
 
 	hash := make(map[string]Echo)
 	size := len(db.Idx.List)
 	for i := 0; i < size; i++ {
 		id := db.Idx.List[i]
 		info := db.Idx.Hash[id]
 		if info.Off < 0 {
 			continue
 		}
 		if !db.Match(info, q) {
 			continue
 		}
 		e := info.Echo
 		if names != nil { // filter?
 			if _, ok := filter[e]; !ok {
 				continue
 			}
 		}
 		if v, ok := hash[e]; ok {
 			if info.Repto == "" {
 				v.Topics++
 			}
 			v.Count++
 			v.Last = info
 			hash[e] = v
 		} else {
 			v := Echo{Name: e, Count: 1, Last: info}
 			if info.Repto == "" {
 				v.Topics = 1
 			}
 			hash[e] = v
 		}
 	}
 	if names != nil {
 		for _, v := range names {
 			n := hash[v]
 			list = append(list, &n)
 		}
 	} else {
 		for _, v := range hash {
 			n := v
 			list = append(list, &n)
 		}
 	}
 	for _, v := range list {
 		v.Msg = db.GetFast(v.Last.Id)
 		if v.Msg == nil {
 			Error.Printf("Can not get echo last message: %s", v.Last.Id)
 			v.Msg = &Msg{}
 		}
 	}
 	sort.SliceStable(list, func(i, j int) bool {
 		return list[i].Msg.Date > list[j].Msg.Date
 	})
 	return list
 }
 
 // Make query and retuen ids as slice of strings.
 // Does lock. Can create/load index if needed.
 // r: request, see Query
 func (db *DB) SelectIDS(r Query) []string {
 	var Resp []string
 	db.Sync.Lock()
 	defer db.Sync.Unlock()
 	db.Lock()
 	defer db.Unlock()
 
 	if err := db.LoadIndex(); err != nil {
 		return Resp
 	}
 	size := len(db.Idx.List)
 	if size == 0 {
 		return Resp
 	}
 
 	db.IdxSync.RLock()
 	defer db.IdxSync.RUnlock()
 
 	if r.Start < 0 {
 		start := 0
 		for i := size - 1; i >= 0; i-- {
 			id := db.Idx.List[i]
 			if db.Match(db.Idx.Hash[id], r) {
 				Resp = prependStr(Resp, id)
 				start -= 1
 				if start == r.Start {
 					break
 				}
 			}
 		}
 		if r.Lim > 0 && len(Resp) > r.Lim {
 			Resp = Resp[0:r.Lim]
 		}
 		return Resp
 	}
 	found := 0
 	for i := r.Start; i < size; i++ {
 		id := db.Idx.List[i]
 		if db.Match(db.Idx.Hash[id], r) {
 			Resp = append(Resp, id)
 			found += 1
 			if r.Lim > 0 && found == r.Lim {
 				break
 			}
 		}
 	}
 	return Resp
 }
 
 // Internal function. Get slice of MsgInfo pointers
 // and create information about topics.
 // Information returns in form of: [topicid][]ids
 // topic id is the msg id of most old parent in echo
 // ids - is the messages in this topic
 func (db *DB) GetTopics(mi []*MsgInfo) map[string][]string {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 
 	intopic := make(map[string]string)
 	topics := make(map[string][]string)
 
 	if err := db.LoadIndex(); err != nil {
 		// FIXME: handle this error
 		panic(err)
 	}
 	for _, m := range mi {
 		if _, ok := intopic[m.Id]; ok {
 			continue
 		}
 		var l []*MsgInfo
 		if m.Topic != "" { // fast path
 			if len(topics[m.Topic]) == 0 {
 				topics[m.Topic] = append(topics[m.Topic], m.Topic)
 			}
 			if m.Id != m.Topic {
 				topics[m.Topic] = append(topics[m.Topic], m.Id)
 				intopic[m.Id] = m.Topic
 			}
 			continue
 		}
 		for p := m; p != nil; p = db.LookupFast(p.Repto, false) {
 			if p.Repto == p.Id || p.Topic == "visited" { // loop?
 				p.Topic = ""
 				break
 			}
 			if m.Echo != p.Echo {
 				continue
 			}
 			if p.Topic == "" {
 				p.Topic = "visited"
 			}
 			l = append(l, p)
 		}
 		if len(l) == 0 {
 			continue
 		}
 		t := l[len(l)-1]
 		if len(topics[t.Id]) == 0 {
 			topics[t.Id] = append(topics[t.Id], t.Id)
 		}
 		sort.SliceStable(l, func(i int, j int) bool {
 			return l[i].Num < l[j].Num
 		})
 		for _, i := range l {
 			if i.Id == t.Id {
 				i.Topic = t.Id
 				continue
 			}
 			if _, ok := intopic[i.Id]; ok {
 				continue
 			}
 			topics[t.Id] = append(topics[t.Id], i.Id)
 			intopic[i.Id] = t.Id
 			i.Topic = t.Id
 		}
 	}
 
 	return topics
 }
 
 // Store decoded message in database
 // If message exists, returns error
 func (db *DB) Store(m *Msg) error {
 	if r, _ := m.Tag("repto"); r == "" { //  new one!
 		if m.Echo == "std.hugeping" && m.Addr != "ping,1" {
 			return errors.New("Access denied")
 		}
 	}
 	return db._Store(m, false)
 }
 
 // Store decoded message in database
 // even it is exists. So, it's like Edit operation.
 // While index loaded, it got last version of message data.
 func (db *DB) Edit(m *Msg) error {
 	return db._Store(m, true)
 }
 
 // Blacklist decoded message.
 // Blacklisting is adding special tag: access/blacklist and Edit operation
 // to store it in DB. While loading index, blacklisted messages
 // are marked by negative Off field (-1).
 func (db *DB) Blacklist(m *Msg) error {
 	if err := m.Tags.Add("access/blacklist"); err != nil {
 		return err
 	}
 	return db.Edit(m)
 
 	//db.Sync.Lock()
 	//defer db.Sync.Unlock()
 	//db.Lock()
 	//defer db.Unlock()
 	// repto, _ := m.Tag("repto")
 	// if repto != "" {
 	// 	repto = ":" + repto
 	// }
 	// rec := fmt.Sprintf("%s:%s:%d%s", m.MsgId, m.Echo, -1, repto)
 	// if err := append_file(db.IndexPath(), rec); err != nil {
 	// 	return err
 	// }
 	// return nil
 }
 
 // Internal function used by Store. See Store comment.
 func (db *DB) _Store(m *Msg, edit bool) error {
 	db.Sync.Lock()
 	defer db.Sync.Unlock()
 	db.Lock()
 	defer db.Unlock()
 	repto, _ := m.Tag("repto")
 	if err := db.LoadIndex(); err != nil {
 		return err
 	}
 
 	db.IdxSync.RLock()
 	defer db.IdxSync.RUnlock()
 
 	if _, ok := db.Idx.Hash[m.MsgId]; ok && !edit { // exist and not edit
 		return errors.New("Already exists")
 	}
 	//	if repto != "" {
 	//		if _, ok := db.Idx.Hash[repto]; !ok { // repto is absent, we should avoid loops!
 	//			return errors.New("Wrong repto: " + repto)
 	//		}
 	//	}
 	fi, err := os.Stat(db.BundlePath())
 	var off int64
 	if err == nil {
 		off = fi.Size()
 	}
 	if v, _ := m.Tag("access"); v == "blacklist" {
 		off = -1
 	}
 	if err := append_file(db.BundlePath(), m.Encode()); err != nil {
 		return err
 	}
 
 	rec := fmt.Sprintf("%s:%s:%d:%s:%s:%s", m.MsgId, m.Echo, off, m.To, m.From, repto)
 	if err := append_file(db.IndexPath(), rec); err != nil {
 		return err
 	}
 	return nil
 }
 
 // Opens DB and returns pointer to DB object.
 // path is the path to db. By default it is ./db
 // Index will be named as path + ".idx"
 func OpenDB(path string) *DB {
 	var db DB
 	db.Path = path
 	info, err := os.Stat(filepath.Dir(path))
 	if err != nil || !info.IsDir() {
 		return nil
 	}
 	db.Name = "node"
 	//	db.Idx = make(map[string]Index)
 	return &db
 }
 
 // User entry in points.txt db
 // User with Id == 1 is superuser.
 // Tags: custom information (like avatars :) in Tags format
 type User struct {
 	Id     int32
 	Name   string
 	Mail   string
 	Secret string
 	Token  string
 	Tags   Tags
 }
 
 // User database.
 // ModTime: last modification time of points.txt to detect DB changes.
 // FileSize - size of points.txt to detect DB changes.
 // Names: holds User structure by user name
 // ById: holds user name by user id
 // Tokens: holds user name by user token
 // List: holds user names as list
 type UDB struct {
 	Path     string
 	Names    map[string]User
 	ById     map[int32]string
 	Tokens   map[string]string
 	List     []string
 	Sync     sync.RWMutex
 	ModTime  int64
 	FileSize int64
 }
 
 // Check username if it is valid
 func IsUsername(u string) bool {
 	return !strings.ContainsAny(u, ":\n\r\t/") &&
 		!strings.HasPrefix(u, " ") &&
 		!strings.HasSuffix(u, " ") &&
 		len(u) <= 16 && len(u) > 2
 }
 
 // Check password if it is valid to be used
 func IsPassword(u string) bool {
 	return len(u) >= 1
 }
 
 // Make secret from string.
 // String is something like id + user + password
 func MakeSecret(msg string) string {
 	h := sha256.Sum256([]byte(msg))
 	hash, err := bcrypt.GenerateFromPassword(h[:], bcrypt.DefaultCost)
 	if err != nil {
 		Error.Printf("bcrypt problem")
 		return "bcryptProblem"
 	}
 	return string(hash)
 }
 
 // Return token for username or "" if no such user
 func (db *UDB) Token(User string) string {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	ui, ok := db.Names[User]
 	if !ok {
 		return ""
 	}
 	return ui.Token
 }
 
 // Returns true if user+password is valid
 func (db *UDB) Auth(User string, Passwd string) bool {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	ui, ok := db.Names[User]
 	if !ok {
 		return false
 	}
 	locked, _ := ui.Tags.Get("locked")
 	if locked == "" {
 		Error.Printf("Can't get locked tag (%s)", User)
 		return false
 	}
 	if locked != "no" {
 		Info.Printf("Login locked user attempt (%s)", User)
 		return false
 	}
 	secret := sha256.Sum256([]byte(User+Passwd))
 	return bcrypt.CompareHashAndPassword([]byte(ui.Secret), secret[:]) == nil
 }
 
 // Returns true if token is valid
 func (db *UDB) Access(Token string) bool {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	_, ok := db.Tokens[Token]
 	return ok
 }
 
 // Return username for given Token
 func (db *UDB) Name(Token string) string {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	name, ok := db.Tokens[Token]
 	if ok {
 		return name
 	}
 	Error.Printf("No user for Token: %s", Token)
 	return ""
 }
 
 // Return User pointer for given Token
 func (db *UDB) UserInfo(Token string) *User {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	name, ok := db.Tokens[Token]
 	if ok {
 		v := db.Names[name]
 		return &v
 	}
 	Error.Printf("No user for token: %s", Token)
 	return nil
 }
 
 // Return User pointer for user id
 func (db *UDB) UserInfoId(id int32) *User {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	name, ok := db.ById[id]
 	if ok {
 		v := db.Names[name]
 		return &v
 	}
 	Error.Printf("No user for Id: %d", id)
 	return nil
 }
 
 // Return User pointer for given user name
 func (db *UDB) UserInfoName(name string) *User {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	v, ok := db.Names[name]
 	if ok {
 		return &v
 	}
 	return nil
 }
 
 // Return user id for given token
 func (db *UDB) Id(token string) int32 {
 	db.Sync.RLock()
 	defer db.Sync.RUnlock()
 	name, ok := db.Tokens[token]
 	if ok {
 		v, ok := db.Names[name]
 		if !ok {
 			return -1
 		}
 		return v.Id
 	}
 	Error.Printf("No user for token: %s", token)
 	return -1
 }
 
 var emailRegex = regexp.MustCompile("^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$")
 
 // Add (register) user in database
 // Mail is optional but someday it will be used in registration process
 func (db *UDB) Add(Name string, Mail string, Passwd string) error {
 	db.Sync.Lock()
 	defer db.Sync.Unlock()
 
 	if _, ok := db.Names[Name]; ok {
 		return errors.New("User already exists")
 	}
 	if !IsUsername(Name) {
 		return errors.New("Wrong username")
 	}
 	if !IsPassword(Passwd) {
 		return errors.New("Bad password")
 	}
 	if !emailRegex.MatchString(Mail) {
 		return errors.New("Wrong email")
 	}
 	var id int32 = 0
 	for _, v := range db.Names {
 		if v.Id > id {
 			id = v.Id
 		}
 	}
 	id++
 	var u User
 	u.Name = Name
 	u.Mail = Mail
 	u.Secret = MakeSecret(Name + Passwd)
 	u.Tags = NewTags("locked/yes")
 	db.List = append(db.List, u.Name)
 	if err := append_file(db.Path, fmt.Sprintf("%d:%s:%s:%s:%s",
 		id, Name, Mail, u.Secret, u.Tags.String())); err != nil {
 		return err
 	}
 	return nil
 }
 
 // Open user database and return pointer to UDB object
 func OpenUsers(path string) *UDB {
 	var db UDB
 	db.Path = path
 	return &db
 }
 
 // Change (replace) information about user.
 // Gets pointer to User object and write it in DB, replacing old information.
 // Works atomically using rename.
 func (db *UDB) Edit(u *User) error {
 	db.Sync.Lock()
 	defer db.Sync.Unlock()
 	if _, ok := db.Names[u.Name]; !ok {
 		return errors.New("No such user")
 	}
 	db.Names[u.Name] = *u // new version
 	os.Remove(db.Path + ".tmp")
 	for _, Name := range db.List {
 		ui := db.Names[Name]
 		if err := append_file(db.Path+".tmp", fmt.Sprintf("%d:%s:%s:%s:%s",
 			ui.Id, Name, ui.Mail, ui.Secret, ui.Tags.String())); err != nil {
 			return err
 		}
 	}
 	if err := os.Rename(db.Path+".tmp", db.Path); err != nil {
 		return err
 	}
 	db.ModTime = 0 // force to reload
 	return nil
 }
 
 // Load user information in memory if it is needed (ModTime or FileSize changed).
 // So, it is safe to call it on every request.
 func (db *UDB) LoadUsers() error {
 	db.Sync.Lock()
 	defer db.Sync.Unlock()
 	var mtime int64
 	var fsize int64
 	file, err := os.Open(db.Path)
 	if err == nil {
 		info, err := file.Stat()
 		file.Close()
 		if err != nil {
 			Error.Printf("Can not stat %s file: %s", db.Path, err)
 			return err
 		}
 		mtime = info.ModTime().Unix()
 		fsize = info.Size()
 	} else if os.IsNotExist(err) {
 		mtime = 0
 	} else {
 		Error.Printf("Can not open %s file: %s", db.Path, err)
 		return err
 	}
 	if db.ModTime == mtime && db.FileSize == fsize {
 		return nil
 	}
 	// save old tokens before reload
 	old_tokens := make(map[string]string)
 	for otoken, oname := range db.Tokens {
         old_tokens[oname] = otoken
     }
 	db.Names = make(map[string]User)
 	db.Tokens = make(map[string]string)
 	db.ById = make(map[int32]string)
 	db.List = nil
 	err = FileLines(db.Path, func(line string) bool {
 		a := strings.Split(line, ":")
 		if len(a) < 4 {
 			Error.Printf("Wrong entry in user DB: %s", line)
 			return true
 		}
 		var u User
 		var err error
 		_, err = fmt.Sscanf(a[0], "%d", &u.Id)
 		if err != nil {
 			Error.Printf("Wrong ID in user DB: %s", a[0])
 			return true
 		}
 		u.Name = a[1]
 		u.Mail = a[2]
 		u.Secret = a[3]
 		u.Tags = NewTags(a[4])
 		//restore token if user onlocked
 		token, ok := old_tokens[u.Name]
 		if ok {
 			locked, _ := u.Tags.Get("locked")
 			if locked != "" && locked == "no" {
 				u.Token = token
 				db.Tokens[token] = u.Name
 			}
 		}
 		db.ById[u.Id] = u.Name
 		db.Names[u.Name] = u
 		db.List = append(db.List, u.Name)
 		return true
 	})
 	if err != nil {
 		Error.Printf("Can not read user DB: %s", err)
 		return errors.New(err.Error())
 	}
 	db.ModTime = mtime
 	db.FileSize = fsize
 	return nil
 }
 
 // Echo database entry
 // Holds echo descriptions in Info hash.
 // List - names of echoareas.
 type EDB struct {
 	Info map[string]string
 	List []string
 	Path string
 }
 
 // Check if echo is exists in echo database
 func (db *EDB) Allowed(name string) bool {
 	if len(db.List) == 0 {
 		return true
 	}
 	if _, ok := db.Info[name]; ok {
 		return true
 	}
 	return false
 }
 
 // Loads echolist database and returns pointer to EDB
 // Supposed to be called only once
 func LoadEcholist(path string) *EDB {
 	var db EDB
 	db.Path = path
 	db.Info = make(map[string]string)
 
 	err := FileLines(path, func(line string) bool {
 		a := strings.SplitN(line, ":", 3)
 		if len(a) < 2 {
 			Error.Printf("Wrong entry in echo DB: %s", line)
 			return true
 		}
 		db.Info[a[0]] = a[2]
 		db.List = append(db.List, a[0])
 		return true
 	})
 	if err != nil {
 		Error.Printf("Can not read echo DB: %s", err)
 		return nil
 	}
 	return &db
 }