Golang bytes.ToLower类(方法)实例源码

func parseline(line []byte, i int) (int, int, int, error) {
	comma := bytes.Index(line, []byte{'#'})
	if comma >= 0 {
		line = line[0:comma]
	}
	if l := len(line); l < 4 {
		return -1, -1, -1, fmt.Errorf("line %d length invalid: %d %q\n", i, l, line)
	}
	rl := bytes.TrimSpace(line)
	rl = re_space.ReplaceAll(rl, []byte{' '})
	chs := bytes.Split(rl, []byte{' '})
	if len(chs) != 2 {
		return -1, -1, -1,
			fmt.Errorf("line %d has %d numbers: %s\n", i, len(chs), rl)
	}
	ret, err := strconv.ParseInt(string(bytes.ToLower(chs[0])), 0, 32)
	if err != nil {
		return -1, -1, -1,
			fmt.Errorf("convert %q to int failed at line %d: %s\n", chs[0], i, err)
	}
	gb2312 := int(ret)
	if gb2312 <= 0x7f {
		return gb2312, gb2312, gb2312, fmt.Errorf("No need convert for ascii 0x%x\n", gb2312)
	}
	ret, err = strconv.ParseInt(string(bytes.ToLower(chs[1])), 0, 32)
	if err != nil {
		return -1, -1, -1,
			fmt.Errorf("convert %q to int failed at line %d: %s\n", chs[1], i, err)
	}
	unicode := int(ret)
	utf8 := unicode2utf8(unicode)

	return gb2312, unicode, utf8, nil
}

// Equals reports whether a pattern is identical to another pattern.
func (c IgnoreCase) Equals(pat patterns.Pattern) bool {
	c2, ok := pat.(IgnoreCase)
	if ok && bytes.Equal(bytes.ToLower(c), bytes.ToLower(c2)) {
		return true
	}
	return false
}

func ParseIni(reader io.Reader) (*Config, error) {
	section, lastKey, cfg := "/", "", make(map[string]string)
	firstLine, scanner := true, bufio.NewScanner(reader)

	for scanner.Scan() {
		s := scanner.Bytes()
		if firstLine {
			s = removeUtf8Bom(s)
			firstLine = false
		}

		s = bytes.TrimSpace(s)
		if len(s) == 0 || s[0] == '#' { // empty or comment
			continue
		}

		if s[0] == '[' && s[len(s)-1] == ']' { // section
			s = bytes.TrimSpace(s[1 : len(s)-1])
			if len(s) >= 0 {
				section = "/" + string(bytes.ToLower(s))
			}
			continue
		}

		k, v := "", ""
		if i := bytes.IndexByte(s, '='); i != -1 {
			k = string(bytes.ToLower(bytes.TrimSpace(s[:i])))
			v = string(bytes.TrimSpace(s[i+1:]))
		}

		if len(k) > 0 {
			lastKey = section + "/" + k
			cfg[lastKey] = v
			continue
		} else if len(lastKey) == 0 {
			continue
		}

		c, lv := byte(128), cfg[lastKey]
		if len(lv) > 0 {
			c = lv[len(lv)-1]
		}

		if len(v) == 0 { // empty value means a new line
			cfg[lastKey] = lv + "\n"
		} else if c < 128 && c != '-' && v[0] < 128 { // need a white space?
			// not good enough, but should be ok in most cases
			cfg[lastKey] = lv + " " + v
		} else {
			cfg[lastKey] = lv + v
		}
	}

	if e := scanner.Err(); e != nil {
		return nil, e
	}

	return &Config{data: cfg}, nil
}

// PremiumUserHandle user logs + replies
func PremiumUserHandle(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	nick := bytes.ToLower([]byte(vars["nick"]))
	filter := func(line []byte) bool {
		return bytes.Contains(bytes.ToLower(line), nick)
	}
	serveFilteredLogs(w, common.GetConfig().LogPath+"/"+vars["channel"]+"/"+vars["month"], filter)
}

func local_ac(view *view) ([]ac_proposal, int) {
	var dups llrb_tree
	var others llrb_tree
	proposals := make([]ac_proposal, 0, 100)
	prefix := view.cursor.word_under_cursor()

	// update word caches
	view.other_buffers(func(buf *buffer) {
		buf.update_words_cache()
	})

	collect := func(ignorecase bool) {
		words := view.collect_words([][]byte(nil), &dups, ignorecase)
		for _, word := range words {
			proposals = append(proposals, ac_proposal{
				display: word,
				content: word,
			})
		}

		lprefix := prefix
		if ignorecase {
			lprefix = bytes.ToLower(prefix)
		}
		view.other_buffers(func(buf *buffer) {
			buf.words_cache.walk(func(word []byte) {
				lword := word
				if ignorecase {
					lword = bytes.ToLower(word)
				}
				if bytes.HasPrefix(lword, lprefix) {
					ok := dups.insert_maybe(word)
					if !ok {
						return
					}
					others.insert_maybe(word)
				}
			})
		})
		others.walk(func(word []byte) {
			proposals = append(proposals, ac_proposal{
				display: word,
				content: word,
			})
		})
		others.clear()
	}
	collect(false)
	if len(proposals) == 0 {
		collect(true)
	}

	if prefix != nil {
		return proposals, utf8.RuneCount(prefix)
	}
	return proposals, 0
}

func searchKey(nick, filter string) func([]byte) bool {
	nick += ":"
	return func(line []byte) bool {
		for i := 0; i < len(nick); i++ {
			if i+LogLinePrefixLength > len(line) || line[i+LogLinePrefixLength] != nick[i] {
				return false
			}
		}
		return bytes.Contains(bytes.ToLower(line[len(nick)+LogLinePrefixLength:]), bytes.ToLower([]byte(filter)))
	}
}

func build_comptbl() {
	l1 := []byte("UACBDKRWSN")
	l2 := []byte("ATGVHMYWSN")
	l1_lower := bytes.ToLower(l1)
	l2_lower := bytes.ToLower(l2)
	for i, c1 := range l1 {
		c2 := l2[i]
		comptbl[c1] = c2
		comptbl[c2] = c1
		comptbl[l1_lower[i]] = c2
		comptbl[l2_lower[i]] = c1
	}
}

func (v *view) collect_words(slice [][]byte, dups *llrb_tree, ignorecase bool) [][]byte {
	append_word_full := func(prefix, word []byte, clone bool) {
		lword := word
		lprefix := prefix
		if ignorecase {
			lword = bytes.ToLower(word)
			lprefix = bytes.ToLower(prefix)
		}

		if !bytes.HasPrefix(lword, lprefix) {
			return
		}
		ok := dups.insert_maybe(word)
		if ok {
			if clone {
				slice = append(slice, clone_byte_slice(word))
			} else {
				slice = append(slice, word)
			}
		}
	}

	prefix := v.cursor.word_under_cursor()
	if prefix != nil {
		dups.insert_maybe(prefix)
	}

	append_word := func(word []byte) {
		append_word_full(prefix, word, false)
	}
	append_word_clone := func(word []byte) {
		append_word_full(prefix, word, true)
	}

	line := v.cursor.line
	iter_words_backward(line.data[:v.cursor.boffset], append_word_clone)
	line = line.prev
	for line != nil {
		iter_words_backward(line.data, append_word)
		line = line.prev
	}

	line = v.cursor.line
	iter_words(line.data[v.cursor.boffset:], append_word_clone)
	line = line.next
	for line != nil {
		iter_words(line.data, append_word)
		line = line.next
	}
	return slice
}

func handleHTTPHdr(rdr *bufio.Reader, c net.Conn, header *bytes.Buffer) (addr []byte, err error) {
	hdrXff := "X-Forwarded-For: " + ipAddrFromRemoteAddr(c.RemoteAddr().String())

	var cipherAddr []byte
	for {
		line, isPrefix, err := rdr.ReadLine()
		if err != nil || isPrefix {
			log.Println(err)
			writeErrCode(c, []byte("4107"), true)
			return nil, err
		}

		if bytes.HasPrefix(bytes.ToLower(line), _hdrCipherOrigin) {
			// copy instead of point
			cipherAddr = []byte(string(bytes.TrimSpace(line[(len(_hdrCipherOrigin) + 1):])))
			continue
		}

		if bytes.HasPrefix(bytes.ToLower(line), _hdrForwardedFor) {
			hdrXff = hdrXff + ", " + string(bytes.TrimSpace(line[(len(_hdrForwardedFor)+1):]))
			continue
		}

		if len(bytes.TrimSpace(line)) == 0 {
			// end of HTTP header
			if len(cipherAddr) == 0 {
				writeErrCode(c, []byte("4108"), true)
				return nil, errors.New("empty http cipher address header")
			}
			if len(hdrXff) > 0 {
				header.Write([]byte(hdrXff))
				header.Write([]byte("\n"))
			}
			header.Write(line)
			header.Write([]byte("\n"))
			break
		}

		header.Write(line)
		header.Write([]byte("\n"))

		if header.Len() > _maxHTTPHeaderSize {
			writeErrCode(c, []byte("4108"), true)
			return nil, errors.New("http header size overflowed")
		}
	}

	return cipherAddr, nil
}

// NewRequestHeader returns RequestHeader from bytes
func NewRequestHeader(b []byte) (*RequestHeader, error) {
	lines := bytes.Split(b, eol)
	reqline := bytes.Split(lines[0], []byte{' '})

	headers := [][][]byte{}
	bodySize := 0

	headerLines := lines[1:]
	for _, l := range headerLines {
		tokens := bytes.SplitN(l, []byte{':', ' '}, 2)
		if len(tokens) == 2 {
			headers = append(headers, tokens)
		}

		if bytes.Equal(bytes.ToLower(tokens[0]), []byte("content-length")) {
			size, err := strconv.Atoi(string(tokens[1]))
			if err != nil {
				return nil, err
			}
			bodySize = size
		}
	}

	r := &RequestHeader{
		ReqLineTokens: reqline,
		Headers:       headers,
		BodySize:      bodySize,
		BodyRead:      0,
	}
	return r, nil
}

// load method creates the trie for processing
func (root *Node) load() (ln int) {
	f, err := os.Open(fname)
	defer f.Close()
	if err != nil {
		log.Fatal("File open error: ", err)
	}

	var w []byte
	var nr *Node
	var ltr byte
	var i int
	wk := new(wrk)

	// using Buffered Reader instead of Scanner to avoid the allocation issue
	r := bufio.NewReader(f)

	for w, err = r.ReadBytes('\n'); err == nil; w, err = r.ReadBytes('\n') {
		w, nr = bytes.ToLower(bytes.TrimSpace(w)), root
		for i, ltr = range w {
			wk.depth, nr.chld = i+1, true
			nr = nr.addChar(&ltr, wk)
		}
		nr.word = true
		if nr.depth > ln {
			ln = nr.depth
		}
	}
	return
}

func netshInterfaceIPv6ShowAddress(name string) ([]string, error) {
	// TODO: need to test ipv6 netmask too, but netsh does not outputs it
	out, err := runCmd("netsh", "interface", "ipv6", "show", "address", "interface=\""+name+"\"")
	if err != nil {
		return nil, err
	}
	addrs := make([]string, 0)
	lines := bytes.Split(out, []byte{'\r', '\n'})
	for _, line := range lines {
		if !bytes.HasPrefix(line, []byte("Address")) {
			continue
		}
		if !bytes.HasSuffix(line, []byte("Parameters")) {
			continue
		}
		f := bytes.Split(line, []byte{' '})
		if len(f) != 3 {
			continue
		}
		// remove scope ID if present
		f = bytes.Split(f[1], []byte{'%'})
		addrs = append(addrs, string(bytes.ToLower(bytes.TrimSpace(f[0]))))
	}
	return addrs, nil
}

// ParseBytes is like Parse, except it parses a byte slice instead of a string.
func ParseBytes(b []byte) (UUID, error) {
	var uuid UUID
	if len(b) != 36 {
		if len(b) != 36+9 {
			return uuid, fmt.Errorf("invalid UUID length: %d", len(b))
		}
		if !bytes.Equal(bytes.ToLower(b[:9]), []byte("urn:uuid:")) {
			return uuid, fmt.Errorf("invalid urn prefix: %q", b[:9])
		}
		b = b[9:]
	}
	if b[8] != '-' || b[13] != '-' || b[18] != '-' || b[23] != '-' {
		return uuid, errors.New("invalid UUID format")
	}
	for i, x := range [16]int{
		0, 2, 4, 6,
		9, 11,
		14, 16,
		19, 21,
		24, 26, 28, 30, 32, 34} {
		if v, ok := xtob(b[x], b[x+1]); !ok {
			return uuid, errors.New("invalid UUID format")
		} else {
			uuid[i] = v
		}
	}
	return uuid, nil
}

// fetchTitle attempts to retrieve the title element for a given url.
func fetchTitle(c *proto.Client, m *proto.Message, url string) {
	resp, err := http.Get(url)
	if err != nil {
		return
	}

	body, err := ioutil.ReadAll(resp.Body)
	resp.Body.Close()

	if err != nil {
		return
	}

	body = bytes.ToLower(body)
	s := bytes.Index(body, []byte("<title>"))
	if s == -1 {
		return
	}

	body = body[s+7:]

	e := bytes.Index(body, []byte("</title>"))
	if e == -1 {
		e = len(body) - 1
	}

	body = bytes.TrimSpace(body[:e])

	c.PrivMsg(m.Receiver, "%s's link shows: %s",
		m.SenderName, html.UnescapeString(string(body)))
}

func (options *html) Citation(out *bytes.Buffer, link, title []byte) {
	out.WriteString("<a class=\"cite\" href=\"#")
	out.Write(bytes.ToLower(link))
	out.WriteString("\">")
	out.Write(title)
	out.WriteString("</a>")
}

func findNews(text [][]byte, address, sender string) []byte {
	// prep the address for searching against text
	addr := []byte(address)
	addrStart := bytes.SplitN(addr, []byte("@"), 2)[0]
	// so we can reuse similar addresses?
	if len(addrStart) > 15 {
		addrStart = addrStart[:15]
	}

	var news [][]byte
	badLines := 0
	senderBytes := bytes.ToLower([]byte(sender))
	for _, line := range text {
		line := bytes.Trim(line, "-| ?")
		if isNews(line, addr, addrStart, senderBytes) {
			badLines = 0
			news = append(news, line)

		} else if (len(news) > 0) && (len(line) > 0) {
			badLines++
		}

		// get at most 3 or quit if we have bad rows and at least 2 or over 2 bads and 1 good
		if (len(news) >= 3) || ((badLines > 0) && (len(news) >= 2)) || ((badLines >= 2) && (len(news) >= 1)) {
			break
		}
	}

	return bytes.Join(news, []byte(" "))
}

// IdentifyRedHatRelease tires to identify the derivretives of Red Hat Linux.
// It supports following distributions:
//
//   - CentOS
//   - Red Hat Enterprise Linux
//
// If failed to identify the platform or the platform is the derivatives of
// Red Hat Linux, IdentifyRedHatRelease returns an ErrNotIdentifier.
func IdentifyRedHatRelease() (*Info, error) {
	file, err := os.Open("/etc/redhat-release")
	if err != nil {
		if os.IsNotExist(err) {
			return nil, ErrNotIdentified
		}
		return nil, err
	}
	b, err := ioutil.ReadAll(file)
	if err != nil {
		return nil, err
	}

	var platform Name
	lb := bytes.ToLower(b)
	switch {
	case bytes.HasPrefix(lb, []byte("centos")):
		platform = PlatformCentOS
	case bytes.HasPrefix(lb, []byte("red hat enterprise")):
		platform = PlatformRHEL
	}

	version := ""
	if matches := regexp.MustCompile(`release (\d[\d.]*)`).FindSubmatch(b); len(matches) > 1 {
		version = string(matches[1])
	}

	return &Info{
		Platform: platform,
		Family:   FamilyRHEL,
		Version:  version,
	}, nil
}

func TestAgent_Self(t *testing.T) {
	meta := map[string]string{
		"somekey": "somevalue",
	}
	dir, srv := makeHTTPServerWithConfig(t, func(conf *Config) {
		conf.Meta = meta
	})
	defer os.RemoveAll(dir)
	defer srv.Shutdown()
	defer srv.agent.Shutdown()

	req, err := http.NewRequest("GET", "/v1/agent/self", nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	obj, err := srv.AgentSelf(nil, req)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	val := obj.(AgentSelf)
	if int(val.Member.Port) != srv.agent.config.Ports.SerfLan {
		t.Fatalf("incorrect port: %v", obj)
	}

	if int(val.Config.Ports.SerfLan) != srv.agent.config.Ports.SerfLan {
		t.Fatalf("incorrect port: %v", obj)
	}

	c, err := srv.agent.server.GetLANCoordinate()
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	if !reflect.DeepEqual(c, val.Coord) {
		t.Fatalf("coordinates are not equal: %v != %v", c, val.Coord)
	}
	if !reflect.DeepEqual(meta, val.Meta) {
		t.Fatalf("meta fields are not equal: %v != %v", meta, val.Meta)
	}

	srv.agent.config.DisableCoordinates = true
	obj, err = srv.AgentSelf(nil, req)
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	val = obj.(AgentSelf)
	if val.Coord != nil {
		t.Fatalf("should have been nil: %v", val.Coord)
	}

	// Make sure there's nothing called "token" that's leaked.
	raw, err := srv.marshalJSON(req, obj)
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	if bytes.Contains(bytes.ToLower(raw), []byte("token")) {
		t.Fatalf("bad: %s", raw)
	}
}

func (rr *Reader) readSingleCmd() (cmd *Command, err error) {
	if vals, err := rr.readSingleLineVals(); err != nil {
		return nil, newError(err, "error reading single command")
	} else {
		cmd = new(Command)
		cmd.Name = bytes.ToLower(vals[0])
		cmd.Args = vals[1:]
	}

	fmt.Printf("got cmd '%s\n'", cmd.Name)

	isBulk := RedisCmds[string(cmd.Name)]&REDIS_CMD_BULK == REDIS_CMD_BULK

	// if its a bulk cmd, the last arg is the number of bytes of the real last arg
	// So lets swap it out
	if isBulk {
		if nbytes, err := strconv.Atoi(string(cmd.Args[len(cmd.Args)])); err != nil {
			return nil, newError(err, "parsing bulk argument length failed")
		} else {

			bulkbuf := make([]byte, nbytes)
			rr.rd.Read(bulkbuf)
			cmd.Args[len(cmd.Args)] = bulkbuf
		}
	}

	// The line should end with crlf so check the last char is \r
	return cmd, nil
}

func IsValidCharsets(cs []byte) bool {
	if _, ok := ValidCharsets[string(bytes.ToLower(cs))]; ok {
		return true
	}

	return false
}