Пример #1
0
func (i *Instances) ExportDel(sess, inst, method string, retval int) error {
	i.lck.Lock()
	defer i.lck.Unlock()
	s, found := i.Insts[sess]
	if !found {
		return e.New(ErrSessionNotFound)
	}
	in, found := s.Insts[inst]
	if !found {
		return e.New(ErrInstanceNotFound)
	}
	retvals, found := in.Export()[method]
	if !found {
		return e.New(ErrMethodNotFound)
	}
	_, found = retvals[retval]
	if !found {
		return e.New(ErrReturnValueNotFound)
	}
	delete(retvals, retval)
	if len(retvals) == 0 {
		delete(in.Export(), method)
	}
	return nil
}
Пример #2
0
func NewMongoDb(rawurl, collection string, safe *mgo.Safe, entry Entry, timeout time.Duration) (Storer, error) {
	var err error
	m := &MongoDb{}
	err = chkData(entry)
	if err != nil {
		return nil, e.Forward(err)
	}
	m.tentry = reflect.TypeOf(entry)
	if m.tentry.Kind() != reflect.Ptr {
		m.tentry = reflect.PtrTo(m.tentry)
	}
	m.session, err = mgo.DialWithTimeout(rawurl, timeout)
	if err != nil {
		return nil, e.New(err)
	}
	parsed, err := url.Parse(rawurl)
	if err != nil {
		return nil, e.New(err)
	}
	if safe == nil {
		safe = &mgo.Safe{}
	}
	m.session.SetSafe(safe)
	m.dbname = strings.Trim(parsed.Path, "/")
	m.db = m.session.DB(m.dbname)
	m.collection = collection
	m.c = m.db.C(collection)
	return m, nil
}
Пример #3
0
func (c *clone) Init(inst string) error {
	if c.Num <= 0 {
		return e.New("number of clones invalid")
	}
	if c.Session == nil {
		return e.New("nil Session")
	}
	if c.Num > c.MaxNum {
		return e.New("number of initial streams is greater than the maximun")
	}
	c.inst = inst
	c.once.Do(func() {
		c.conns = make([]connInst, 0, c.Num)
		log.ProtoLevel().Tag("gormethods", "client", "clone").Println("Init clones.")
		for i := 0; i < c.Num; i++ {
			conn, err := c.Session.NamedInstance(c.inst)
			if err != nil {
				log.ProtoLevel().Tag("gormethods", "client", "clone").Printf("New instance failed: %v.", err)
				continue
			}
			c.conns = append(c.conns, conn)
		}
	})
	return nil
}
Пример #4
0
func (i *Instances) Export(sess, inst string, exp *ToExport) error {
	i.lck.Lock()
	defer i.lck.Unlock()
	s, found := i.Insts[sess]
	if !found {
		return e.New(ErrSessionNotFound)
	}
	in, found := s.Insts[inst]
	if !found {
		return e.New(ErrInstanceNotFound)
	}
	m, ok := in.Instance().Type().MethodByName(exp.Method)
	if !ok {
		return e.New(ErrMethodNotFound)
	}
	if exp.RetvalPos >= m.Type.NumOut() {
		return e.New(ErrInvRetval)
	}
	retvals, found := in.Export()[exp.Method]
	if !found {
		retvals = make(map[int]*Export)
		in.Export()[exp.Method] = retvals
	}
	if exp.Export.Client == nil {
		return e.New(ErrInvClient)
	}
	retvals[exp.RetvalPos] = exp.Export
	return nil
}
Пример #5
0
//NewMulti creates a MultiLog
func NewMulti(vals ...interface{}) LogBackend {
	if len(vals)%2 != 0 {
		Fail(e.New("parameters must be in pair of LogBackend and Formatter"))
		return nil
	}
	l := len(vals) / 2
	mp := make([]LogBackend, 0, l)
	for i := 0; i < len(vals); i += 2 {
		bak, ok := vals[i].(LogBackend)
		if !ok {
			Fail(e.New("not a LogBackend"))
			return nil
		}
		f, ok := vals[i+1].(Formatter)
		if !ok {
			Fail(e.New("not a Formatter"))
			return nil
		}
		bak.F(f)
		mp = append(mp, bak)
	}
	return &MultiLog{
		mp: mp,
	}
}
Пример #6
0
func (a *Server) bind() (conn *net.UDPConn, err error) {
	if !a.NotMulticast && a.iface.Flags&net.FlagMulticast == net.FlagMulticast {
		gaddr, err := a.groupAddr()
		if err != nil {
			return nil, e.Forward(err)
		}
		conn, err = net.ListenMulticastUDP(a.Proto(), a.iface, gaddr)
		if err != nil {
			return nil, e.New(err)
		}
	} else {
		server, err := net.ResolveUDPAddr(a.Proto(), ":"+a.Port)
		if err != nil {
			return nil, e.New(err)
		}
		conn, err = net.ListenUDP(a.Proto(), server)
		if err != nil {
			return nil, e.New(err)
		}
	}
	a.ipver(conn.LocalAddr())
	_, a.Port, err = utilNet.SplitHostPort(conn.LocalAddr().String())
	if err != nil {
		return nil, e.Forward(err)
	}
	return
}
Пример #7
0
// Put inserts in the database the struct in v, v must have the fild _id and
// the field _rev both strings. Like the TestStruct struct.
func (c *Couch) Put(v interface{}) (id, rev string, err error) {
	data, err := json.Marshal(v)
	if err != nil {
		return "", "", e.Push(err, "can't serialize the data")
	}
	id = grepId(data)
	if id == "" {
		return "", "", e.New("document have no id")
	}
	code, resp, err := c.put(id, "", data)
	if err != nil && code == 409 {
		return "", "", e.Push(err, ErrDocConflict)
	} else if err != nil {
		return "", "", e.Push(err, "can't put the document")
	}
	if code == http.StatusCreated {
		ir := new(response)
		err := json.Unmarshal(resp, ir)
		if err != nil {
			return "", "", e.Push(e.Push(err, "can't desserialize returned data"), "can't put the document")
		}
		if !ir.Ok {
			return "", "", e.New("put failed")
		}
		return ir.Id, ir.Rev, nil
	}
	return "", "", e.Push(e.Push(err, e.New("received wrong response code, %v", code)), "can't put the document")
}
Пример #8
0
// PingHttp connect a http or https server and try to
// receive something. If the server return a code different
// of 2xx, it will fail. Ignores insecure certificates.
func PingHttp(url *url.URL) error {
	resp, err := httpClient.Get(url.String())
	if e.Contains(err, "connection refused") {
		return e.Push(e.New(err), "get failed: connection refused")
	} else if err != nil {
		return e.Push(e.New(err), "get failed")
	}
	defer resp.Body.Close()
	buf := make([]byte, 4096)
	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		n, err := resp.Body.Read(buf)
		if err != nil && err != io.EOF {
			return e.Forward(err)
		}
		buf = buf[:n]
		//status.Log(status.Protocol, "PingHttp status code is %v and received it from server: %v", resp.StatusCode, string(buf))
		log.ProtoLevel().Printf("PingHttp status code is %v and received it from server: %v", resp.StatusCode, string(buf))
		return e.New("returned status code %v, expected 2xx", resp.StatusCode)
	}
	_, err = resp.Body.Read(buf)
	if err != nil && err != io.EOF {
		return e.Forward(err)
	}
	return nil
}
Пример #9
0
// TypeOf returns the type of val. If samething wrong occur return a error.
// This functoin don't panic.
func TypeOf(val reflect.Value) (t reflect.Type, err error) {
	defer func() {
		r := recover()
		if r != nil {
			switch v := r.(type) {
			case error:
				err = e.Forward(v)
			case string:
				if strings.Contains(v, "runtime error") {
					panic(r)
				}
				err = e.New(v)
			default:
				err = e.New("unable to type switch the recover data")
			}
		}
	}()
	t = val.Type()
	if t.Kind() == reflect.Interface {
		if val.Elem().IsValid() {
			t = val.Elem().Type()
		} else {
			err = e.New("invalid interface")
		}
	}
	return
}
Пример #10
0
func (t *transaction) Put(key string, data interface{}) error {
	if !t.write {
		return e.New(ErrReadOnly)
	}
	if key == "" {
		return e.New(ErrInvKey)
	}
	t.m[key] = data
	idx := *t.idx
	defer func() {
		*t.idx = idx
	}()
	if len(idx) == 0 {
		idx = append(idx, key)
		return nil
	}
	i := searchString(idx, key)
	if i >= len(idx) || idx[i] != key {
		if i+1 > len(idx) {
			idx = append(idx, key)
			return nil
		}
		idx = append(idx[:i], append([]string{key}, idx[i:]...)...)
	}
	return nil
}
Пример #11
0
// Delete deletes from database the id id with rev revision.
// If rev is empty Delete deletes the last revision.
func (c *Couch) Delete(id, rev string) (string, error) {
	if rev == "" {
		revision := new(idRev)
		err := c.Get(id, "", revision)
		if e.Equal(err, ErrCantGetDoc) {
			return "", e.Push(err, ErrDocDontExist)
		} else if err != nil {
			return "", e.Push(err, "not deleted")
		}
		rev = revision.Rev
	}
	rev = "rev=" + rev
	code, resp, err := c.delete(id, rev, nil)
	if err != nil && code == 404 {
		return "", e.Push(err, ErrDocDontExist)
	} else if err != nil {
		return "", e.Push(err, "not deleted")
	}
	if code != http.StatusOK && code != http.StatusAccepted {
		return "", e.New("can't delete the document, wrong code: %v", code)
	}
	dr := new(response)
	err = json.Unmarshal(resp, dr)
	if err != nil {
		return "", e.Push(e.Push(err, "can't desserialize returned data"), "can't put the document")
	}
	if !dr.Ok {
		return "", e.New("delete failed")
	}
	if dr.Id != id {
		return "", e.New("response with the wrong id")
	}
	return dr.Rev, nil
}
Пример #12
0
func (c *client) do(method, path, params string, body []byte) (int, []byte, error) {
	url := utilUrl.Copy(c.url)
	url.Path += path
	url.RawQuery = params

	var buf io.Reader
	if len(body) > 0 {
		buf = bytes.NewBuffer(body)
	}

	req, err := http.NewRequest(method, url.String(), buf)
	if err != nil {
		return 0, nil, e.New("can't create request")
	}

	if c.url.User != nil {
		req.Header.Set("Authorization", authorizationHeader(url.User.String()))
	}
	req.Header.Set("Content-Type", "application/json")

	resp, err := HttpClient.Do(req)
	if err != nil {
		return 0, nil, e.Push(err, "can't put")
	}
	defer resp.Body.Close()

	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		return resp.StatusCode, nil, e.New("wrong status code - %v: %v", resp.StatusCode, resp.Status)
	}

	var data []byte
	data, _ = ioutil.ReadAll(resp.Body)

	return resp.StatusCode, data, nil
}
Пример #13
0
func (c *Constructors) Construct(name string, args ...interface{}) (reflect.Value, error) {
	c.lck.Lock()
	defer c.lck.Unlock()
	con, found := c.constructors[name]
	if !found {
		t, err := types.GetType(name)
		if err != nil {
			return reflect.Value{}, e.New(ErrTypeNotFound)
		}
		return types.Make(t), nil
	}
	vals := make([]reflect.Value, 0, len(args))
	for _, arg := range args {
		vals = append(vals, reflect.ValueOf(arg))
	}
	retvals := con.Call(vals)
	if len(retvals) != 2 {
		return reflect.Value{}, e.New(ErrInvReturn)
	}
	if retvals[1].Interface() != nil {
		err, ok := retvals[1].Interface().(error)
		if !ok {
			return reflect.Value{}, e.New(ErrInvReturn)
		}
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
	}
	return retvals[0], nil
}
Пример #14
0
func (i *Intface) getInt() error {
	if i.Interface != "" && i.iface == nil {
		ints, err := net.Interfaces()
		if err != nil {
			return e.New(err)
		}
		for _, in := range ints {
			if in.Name == i.Interface {
				i.iface = &in
				return nil
			}
		}
		return e.New("none interface with this name")
	} else if i.Interface == "" && i.iface == nil {
		ints, err := net.Interfaces()
		if err != nil {
			return e.New(err)
		}
		var intName string
		for _, in := range ints {
			if in.Flags&net.FlagMulticast == net.FlagMulticast || in.Flags&net.FlagBroadcast == net.FlagBroadcast || in.Flags&net.FlagBroadcast == net.FlagBroadcast {
				_, intName = getInterface(in)
				if intName == "" {
					continue
				}
				i.Interface = intName
				i.iface = &in
				break
			}
		}
	}
	return nil
}
Пример #15
0
// NewStdFormatter crete a new formatter.
func NewStdFormatter(delim, tmpl string, entry Entry, values map[string]interface{}, timeformat string) (Formatter, error) {
	if delim == "" {
		return nil, e.New("invalid delimitator")
	}
	if tmpl == "" {
		return nil, e.New("invalid template")
	}
	if entry == nil {
		return nil, e.New("invalid entry")
	}
	if values == nil {
		return nil, e.New("invalid values")
	}
	if timeformat == "" {
		timeformat = TimeDateFormat
	}
	return &StdFormatter{
		Delim:      []byte(delim),
		Tmpl:       []byte(tmpl),
		E:          entry,
		Map:        values,
		Idx:        mkindex(entry),
		TimeFormat: timeformat,
	}, nil
}
Пример #16
0
func makeFunction(f *Func) (*Function, error) {
	var args []*Argument
	if len(f.Params.Arguments) >= 1 {
		args = f.Params.Arguments[0]
	}
	var results []*Argument
	if len(f.Params.Arguments) >= 2 {
		results = f.Params.Arguments[1]
	}
	found := -1
	for i, r := range results {
		if r.Type == "error" {
			found = i
		}
	}
	if found >= 0 && found != len(results)-1 {
		return nil, e.New("one error must be the last result")
	}
	named := false
	for i, r := range results {
		if len(r.Names) > 0 && i == 0 {
			named = true
		}
		if len(r.Names) == 0 && named {
			return nil, e.New("all results must be named")
		} else if len(r.Names) > 0 && !named {
			return nil, e.New("all results must be unnamed")
		}
		if r.Type == "error" && len(r.Names) > 0 && r.Names[len(r.Names)-1] != "err" {
			return nil, e.New("last error must be named err")
		}
	}
	if !named {
		for i, r := range results {
			if r.Type == "error" {
				r.Names = []string{"err"}
				continue
			}
			r.Names = []string{fmt.Sprintf("arg%v", i)}
		}
	}
	for i, arg := range args {
		for j, name := range arg.Names {
			if name == "_" {
				arg.Names[j] = "param" + strconv.Itoa(i) + strconv.Itoa(j)
			}
		}
	}
	function := &Function{
		Name:      f.Name,
		RecvVar:   f.Recv,
		RecvType:  f.RecvType,
		Arguments: args,
		Results:   results,
		ReturnErr: found >= 0,
		Comments:  f.Comments,
	}
	return function, nil
}
Пример #17
0
// Check if a tag is formed with the corrects characters
func CheckTag(tag string) error {
	for _, v := range tag {
		if !u.IsLetter(v) && !unicode.IsDigit(v) && v != ' ' && v != '-' && v != '_' && v != '.' && v != '/' && v != ':' {
			return e.Push(e.New(ErrInvalidTagChar), e.New("the character '%v' is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}
Пример #18
0
func CheckDomain(domain string) error {
	for _, v := range domain {
		if !uni.IsLetter(v) && !unicode.IsDigit(v) && v != '.' {
			return e.Push(e.New("invalid domain name"), e.New("the character '%v' in redirect is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}
Пример #19
0
func CheckObjectName(name string) error {
	for _, v := range name {
		if !uni.IsLetter(v) && !unicode.IsDigit(v) && v != '-' && v != '_' && v != '*' && v != '{' && v != '}' && v != '/' && v != '.' && v != '[' && v != ']' {
			return e.Push(e.New(text.ErrInvCharacter), e.New("the character '%v' in object name is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}
Пример #20
0
// CheckHash the hash of a password.
func CheckHash(name string) error {
	for _, v := range name {
		if !uni.IsLetter(v) && !unicode.IsDigit(v) && v != '-' && v != '_' && v != '.' && v != '=' {
			return e.Push(e.New(text.ErrInvCharacter), e.New("the character '%v' in instance name is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}
Пример #21
0
Файл: dns.go Проект: fcavani/net
func lookupHost(host string, config *dns.ClientConfig) (addrs []string, err error) {
	if utilNet.IsValidIpv4(host) || utilNet.IsValidIpv6(host) {
		return []string{host}, nil
	}
	if host == "localhost" {
		return []string{"127.0.0.1", "::1"}, nil
	}

	c := new(dns.Client)
	c.DialTimeout = DialTimeout
	c.ReadTimeout = ReadTimeout
	c.WriteTimeout = WriteTimeout
	m := new(dns.Msg)
	m.SetQuestion(dns.Fqdn(host), dns.TypeA)
	var r *dns.Msg
	for i := 0; i < len(config.Servers); i++ {
		r, _, err = c.Exchange(m, config.Servers[i]+":"+config.Port)
		if err != nil {
			continue
		}
		err = nil
	}
	if err != nil {
		return nil, e.Forward(err)
	}
	if r.Rcode != dns.RcodeSuccess {
		return nil, e.New("can't resolve %v", host)
	}

	addrs = make([]string, 0, 10)
	for _, a := range r.Answer {
		if addr, ok := a.(*dns.A); ok {
			addrs = append(addrs, addr.A.String())
		}
	}

	m.SetQuestion(dns.Fqdn(host), dns.TypeAAAA)
	for i := 0; i < len(config.Servers); i++ {
		r, _, err = c.Exchange(m, config.Servers[0]+":"+config.Port)
		if err != nil {
			continue
		}
		err = nil
	}
	if err != nil {
		return nil, e.Forward(err)
	}
	if r.Rcode != dns.RcodeSuccess {
		return nil, e.New("no success")
	}

	for _, a := range r.Answer {
		if addr, ok := a.(*dns.AAAA); ok {
			addrs = append(addrs, addr.AAAA.String())
		}
	}
	return
}
Пример #22
0
func (s StdFormatter) Format(entry Entry) (out []byte, err error) {
	val := reflect.Indirect(reflect.ValueOf(entry))
	if val.Kind() != reflect.Struct {
		return nil, e.New("formater only accept entries that are structs ")
	}

	if val.Type() != reflect.Indirect(reflect.ValueOf(s.E)).Type() {
		return nil, e.New(ErrNotSupported)
	}

	out = make([]byte, len(s.Tmpl), len(s.Tmpl)*2)
	copy(out, s.Tmpl)
	for {
		start := bytes.Index(out, s.Delim)
		if start == -1 {
			break
		}
		var end int
		cut := out[start:]
		i := findCut(cut)
		if i > -1 {
			end = start + i
		} else {
			end = start + len(cut)
		}

		name := out[start+len(s.Delim) : end]

		var v string
		bname := string(name)
		fidx, found := s.Idx[bname]
		if found {
			fval := val.Field(fidx.I)
			v = scapeSep(stringfy(fval, s.TimeFormat), s.Delim)
		} else {
			inter, found := s.Map[bname]
			if !found {
				v = ""
			} else {
				fval := reflect.Indirect(reflect.ValueOf(inter))
				v = scapeSep(stringfy(fval, s.TimeFormat), s.Delim)
			}
		}
		if v == "" {
			v = fidx.Def
		}

		vb := []byte(v)

		out = append(out[:start], append(vb, out[end:]...)...)
	}

	scape := scapemark(s.Delim)
	out = bytes.Replace(out, scape, s.Delim, -1)
	out = bytes.Replace(out, []byte{' ', ' '}, []byte{' '}, -1)
	return
}
Пример #23
0
func delete(tx *bolt.Tx, hash, kw, kh []byte) error {
	bimg := tx.Bucket([]byte(images))
	bhits := tx.Bucket([]byte(hits))

	w := bimg.Get(hash)
	if w == nil {
		return e.New(ErrImageNotFound)
	}

	bw := tx.Bucket(append(hash, w...))
	if bw == nil {
		return e.New(ErrImageNotFound)
	}
	h := bw.Get(kw)
	if h == nil {
		return e.New(ErrImageNotFound)
	}

	bh := tx.Bucket([]byte(string(hash) + string(w) + string(h)))
	if bh == nil {
		return e.New(ErrImageNotFound)
	}
	err := bh.Delete(kh)
	if err != nil {
		return e.Forward(err)
	}

	if bh.Stats().KeyN <= 0 {
		err = tx.DeleteBucket([]byte(string(hash) + string(w) + string(h)))
		if err != nil {
			return e.Forward(err)
		}
		err = bw.Delete(kw)
		if err != nil {
			return e.Forward(err)
		}
		if bw.Stats().KeyN <= 0 {
			err = tx.DeleteBucket(append(hash, w...))
			if err != nil {
				return e.Forward(err)
			}
			err = bimg.Delete(hash)
			if err != nil {
				return e.Forward(err)
			}
		}
	}

	// BUG: FAULT ADDRS
	hitshash := append(hash, append(kw, kh...)...)
	err = bhits.Delete(hitshash)
	if err != nil {
		return e.Forward(err)
	}

	return nil
}
Пример #24
0
func CheckEmail(email string) error {
	if len(email) < MinEmailLen || len(email) > MaxEmailLen {
		return e.New(ErrInvEmailLength)
	}
	if email != reMail.FindString(email) {
		return e.New(ErrInvEmailString)
	}
	return nil
}
Пример #25
0
func PingImap(url *url.URL) error {
	if url.Scheme != "imap" && url.Scheme != "imaps" {
		return e.New("not an imap/imaps scheme")
	}
	c, err := dialImap(url.Host)
	if err != nil {
		return e.Push(err, ErrImapFailed)
	}
	defer c.Logout(30 * time.Second)

	if c.Caps["STARTTLS"] {
		_, err := c.StartTLS(tlsConfig)
		if err != nil {
			return e.Push(err, ErrImapFailed)
		}
	}
	if c.Caps["ID"] {
		_, err := c.ID("name", "goimap")
		if err != nil {
			return e.Push(err, ErrImapFailed)
		}
	}

	cmd, err := c.Noop()
	if err != nil {
		return e.Push(err, ErrImapFailed)
	}
	rsp, err := cmd.Result(imap.OK)
	if err != nil {
		return e.Push(err, ErrImapFailed)
	}
	//log.Println(rsp.Status, rsp.Info)
	if rsp.Status != imap.OK {
		return e.New(ErrImapFailed)
	}

	if url.User == nil {
		return nil
	}
	username := url.User.Username()
	pass, ok := url.User.Password()
	if username != "" && ok {
		cmd, err := c.Login(username, pass)
		if err != nil {
			return e.Push(err, ErrImapFailed)
		}
		rsp, err := cmd.Result(imap.OK)
		if err != nil {
			return e.Push(err, ErrImapFailed)
		}
		if rsp.Status != imap.OK {
			return e.New(ErrImapFailed)
		}
	}
	return nil
}
Пример #26
0
func (d *Daemon) kill(num syscall.Signal) error {
	if d.pid == -1 {
		return e.New(ErrNoPid)
	}
	err := syscall.Kill(-d.pid, num)
	if err != nil {
		return e.New(err)
	}
	return nil
}
Пример #27
0
func isOk(buf []byte) (bool, error) {
	if len(buf) < offcmd1 {
		return false, e.New("buffer is too small")
	}
	cmd, b := binary.Uvarint(buf[:offcmd1])
	if b <= 0 {
		return false, e.New("invalid comand")
	}
	return ctrlCommands(cmd) == ok, nil
}
Пример #28
0
// PingTCP try to connect a TCP port.
func PingTCP(url *url.URL) error {
	conn, err := net.Dial("tcp", url.Host)
	if err != nil {
		return e.New(err)
	}
	err = conn.Close()
	if err != nil {
		return e.New(err)
	}
	return nil
}
Пример #29
0
// Check the user password. Graphics character are allowed. See unicode.IsGraphic.
func CheckPassword(pass string, min, max int) error {
	if len(pass) < min || len(pass) > max {
		return e.New(ErrInvalidPassLength)
	}
	for _, r := range pass {
		if !unicode.IsGraphic(r) {
			return e.New(ErrInvalidPassChar)
		}
	}
	return nil
}
Пример #30
0
func CheckText(text string, min, max int) error {
	if len(text) < min || len(text) > max {
		return e.New(ErrInvNumberChars)
	}
	for _, v := range text {
		if !uni.IsLetter(v) && !unicode.IsDigit(v) && v != '\n' && v != ' ' && v != '`' && v != '~' && v != '!' && v != '@' && v != '#' && v != '$' && v != '%' && v != '^' && v != '&' && v != '*' && v != '(' && v != ')' && v != '_' && v != '-' && v != '+' && v != '=' && v != '{' && v != '}' && v != '[' && v != ']' && v != '|' && v != '\\' && v != ':' && v != ';' && v != '"' && v != '\'' && v != '?' && v != '/' && v != ',' && v != '.' {
			return e.Push(e.New(ErrInvCharacter), e.New("the character '%v' is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}