func sortQuery(u *url.URL) {
q := u.Query()
if len(q) == 0 {
return
}
arKeys := make([]string, len(q))
i := 0
for k, _ := range q {
arKeys[i] = k
i++
}
sort.Strings(arKeys)
buf := new(bytes.Buffer)
for _, k := range arKeys {
sort.Strings(q[k])
for _, v := range q[k] {
if buf.Len() > 0 {
buf.WriteRune('&')
}
buf.WriteString(fmt.Sprintf("%s=%s", k, url.QueryEscape(v)))
}
}
// Rebuild the raw query string
u.RawQuery = buf.String()
}
func TestParseCommand_History(t *testing.T) {
t.Parallel()
c := cli.CommandLine{Line: liner.NewLiner()}
defer c.Line.Close()
// append one entry to history
c.Line.AppendHistory("abc")
tests := []struct {
cmd string
}{
{cmd: "history"},
{cmd: " history"},
{cmd: "history "},
{cmd: "History "},
}
for _, test := range tests {
if err := c.ParseCommand(test.cmd); err != nil {
t.Fatalf(`Got error %v for command %q, expected nil.`, err, test.cmd)
}
}
// buf size should be at least 1
var buf bytes.Buffer
c.Line.WriteHistory(&buf)
if buf.Len() < 1 {
t.Fatal("History is borked")
}
}
func TestProgressReader(t *testing.T) {
filename := "progress_test.go"
f, err := os.Open(filename)
defer f.Close()
if err != nil {
log.Fatalln(err)
}
fs, err := os.Stat(filename)
if err != nil {
log.Fatalln(err)
}
p := New()
p.Total = fs.Size()
p.Progress = func(current, total, expected int64) {
log.Println("Reading", current, total, expected)
assert.Equal(t, true, current <= total)
}
b := new(bytes.Buffer)
r := syncreader.New(f, p)
_, err = b.ReadFrom(r)
if err != nil {
log.Fatalln(err)
}
assert.Equal(t, fs.Size(), int64(b.Len()))
}
func (r *roffRenderer) TableRow(out *bytes.Buffer, text []byte) {
if out.Len() > 0 {
out.WriteString("\n")
}
out.Write(text)
out.WriteString("\n")
}
// EvalSymlinks returns the path name after the evaluation of any symbolic
// links.
// If path is relative it will be evaluated relative to the current directory.
func EvalSymlinks(path string) (string, os.Error) {
if runtime.GOOS == "windows" {
// Symlinks are not supported under windows.
_, err := os.Lstat(path)
if err != nil {
return "", err
}
return Clean(path), nil
}
const maxIter = 255
originalPath := path
// consume path by taking each frontmost path element,
// expanding it if it's a symlink, and appending it to b
var b bytes.Buffer
for n := 0; path != ""; n++ {
if n > maxIter {
return "", os.NewError("EvalSymlinks: too many links in " + originalPath)
}
// find next path component, p
i := strings.IndexRune(path, Separator)
var p string
if i == -1 {
p, path = path, ""
} else {
p, path = path[:i], path[i+1:]
}
if p == "" {
if b.Len() == 0 {
// must be absolute path
b.WriteRune(Separator)
}
continue
}
fi, err := os.Lstat(b.String() + p)
if err != nil {
return "", err
}
if !fi.IsSymlink() {
b.WriteString(p)
if path != "" {
b.WriteRune(Separator)
}
continue
}
// it's a symlink, put it at the front of path
dest, err := os.Readlink(b.String() + p)
if err != nil {
return "", err
}
if IsAbs(dest) {
b.Reset()
}
path = dest + string(Separator) + path
}
return Clean(b.String()), nil
}
// format should be one line only, and not end with \n.
func addIndentHeaderComment(b *bytes.Buffer, format string, args ...interface{}) {
if b.Len() > 0 {
fmt.Fprintf(b, "\n\t// "+format+"\n", args...)
} else {
fmt.Fprintf(b, "\t// "+format+"\n", args...)
}
}
func getReaderSize(r io.Reader) (io.Reader, int64) {
// Ideal case, the reader knows its own size.
if lr, ok := r.(Lengther); ok {
return r, int64(lr.Len())
}
// But maybe it's a seeker and we can seek to the end to find its size.
if s, ok := r.(io.Seeker); ok {
pos0, err := s.Seek(0, os.SEEK_CUR)
if err == nil {
posend, err := s.Seek(0, os.SEEK_END)
if err == nil {
_, err = s.Seek(pos0, os.SEEK_SET)
if err == nil {
return r, posend - pos0
} else {
// We moved it forward but can't restore it.
// Seems unlikely, but can't really restore now.
return endingWithErrorReader{strings.NewReader(""), err}, posend - pos0
}
}
}
}
// Otherwise we have to make a copy to calculate how big the reader is.
buf := new(bytes.Buffer)
// TODO(bradfitz): put a cap on this copy? spill to disk after
// a certain point?
_, err := io.Copy(buf, r)
return endingWithErrorReader{buf, err}, int64(buf.Len())
}
func (cmd Script) Run() gribble.Value {
if len(cmd.Command) == 0 {
logger.Warning.Printf("Cannot execute empty script.")
return nil
}
go func() {
var stderr bytes.Buffer
time.Sleep(time.Microsecond)
c := fixScannerBugs(cmd.Command)
fields := strings.Split(c, " ")
script := misc.ScriptPath(fields[0])
if len(script) == 0 {
return
}
c = strings.Join(append([]string{script}, fields[1:]...), " ")
logger.Message.Printf("%s -c [%s]", wm.Config.Shell, c)
shellCmd := exec.Command(wm.Config.Shell, "-c", c)
shellCmd.Stderr = &stderr
err := shellCmd.Run()
if err != nil {
logger.Warning.Printf("Error running script '%s': %s",
cmd.Command, err)
if stderr.Len() > 0 {
logger.Warning.Printf("Error running script '%s': %s",
cmd.Command, stderr.String())
}
}
}()
return nil
}
func (a *authReader) Read(p []byte) (int, error) {
if a.err != nil {
return 0, a.err
}
end := false
// read underlying data
n, err := a.data.Read(p)
if err != nil && err != io.EOF {
a.err = err
return n, a.err
} else if err == io.EOF {
// if we are at the end, calculate the mac
end = true
a.err = err
}
// write any data to mac
_, err = a.mac.Write(p[:n])
if err != nil {
a.err = err
return n, a.err
}
if end {
ab := new(bytes.Buffer)
_, err = io.Copy(ab, a.adata)
if err != nil || ab.Len() != 10 {
a.err = ErrDecryption
return n, a.err
}
if !a.checkAuthentication(ab.Bytes()) {
a.err = ErrAuthentication
return n, a.err
}
}
return n, a.err
}
// ToEnvVarName converts a name into a safe valid environment variable name.
// - All characters are converted to upper case.
// - All accents are removed, for example é is replaced by e
// - Any whitespace is replaced by underscore '_'.
// - The safe name never contains two consecutive underscores '_'. Looks better with only one.
// - Digits 0-9 are allowed.
// - Letters A-Z are allowed.
// - Underscore '_' is allowed.
// - All other characters are removed.
//
// References:
// - http://stackoverflow.com/questions/2821043/allowed-characters-in-linux-environment-variable-names
// - https://blog.golang.org/normalization
func ToEnvVarName(name string) string {
buf := new(bytes.Buffer)
name = norm.NFKD.String(name)
name = strings.ToUpper(name)
var lastRune rune
for _, r := range name {
var writeRune rune
if unicode.IsSpace(r) {
writeRune = '_'
} else if ((r >= 'A') && (r <= 'Z')) || (r == '_') {
writeRune = r
} else if (buf.Len() > 0) && (r >= '0' && r <= '9') { // var must not start with digit
writeRune = r
}
// We don't want to write two consecutive '_' underscores. Looks better with only one.
if (writeRune > 0) && ((writeRune != '_') || (lastRune != '_')) {
buf.WriteRune(writeRune)
lastRune = writeRune
}
}
// Trim underscores from start and end.
varName := strings.Trim(buf.String(), "_")
return varName
}
func (cmd Shell) Run() gribble.Value {
if len(cmd.Command) == 0 {
logger.Warning.Printf("Cannot execute empty command.")
return nil
}
// XXX: This is very weird.
// If I don't put this into its own go-routine and wait a small
// amount of time, commands that start new X clients fail miserably.
// And when I say miserably, I mean they take down X itself.
// For some reason, this avoids that problem. For now...
// (I thought the problem was the grab imposed by a key binding,
// but ungrabbing the keyboard before running this command didn't
// change behavior.)
go func() {
var stderr bytes.Buffer
cmd.Command = fixScannerBugs(cmd.Command)
time.Sleep(time.Microsecond)
logger.Message.Printf("%s -c [%s]", wm.Config.Shell, cmd.Command)
shellCmd := exec.Command(wm.Config.Shell, "-c", cmd.Command)
shellCmd.Stderr = &stderr
err := shellCmd.Run()
if err != nil {
logger.Warning.Printf("Error running '%s': %s", cmd.Command, err)
if stderr.Len() > 0 {
logger.Warning.Printf("Error running '%s': %s",
cmd.Command, stderr.String())
}
}
}()
return nil
}
// String provides a human readable string for RadioTapFlags.
// This string is possibly subject to change over time; if you're storing this
// persistently, you should probably store the RadioTapFlags value, not its string.
func (a RadioTapFlags) String() string {
var out bytes.Buffer
if a.CFP() {
out.WriteString("CFP,")
}
if a.ShortPreamble() {
out.WriteString("SHORT-PREAMBLE,")
}
if a.WEP() {
out.WriteString("WEP,")
}
if a.Frag() {
out.WriteString("FRAG,")
}
if a.FCS() {
out.WriteString("FCS,")
}
if a.Datapad() {
out.WriteString("DATAPAD,")
}
if a.ShortGI() {
out.WriteString("SHORT-GI,")
}
if length := out.Len(); length > 0 {
return string(out.Bytes()[:length-1]) // strip final comma
}
return ""
}
// String provides a human readable string for RadioTapChannelFlags.
// This string is possibly subject to change over time; if you're storing this
// persistently, you should probably store the RadioTapChannelFlags value, not its string.
func (a RadioTapChannelFlags) String() string {
var out bytes.Buffer
if a.Turbo() {
out.WriteString("Turbo,")
}
if a.CCK() {
out.WriteString("CCK,")
}
if a.OFDM() {
out.WriteString("OFDM,")
}
if a.Ghz2() {
out.WriteString("Ghz2,")
}
if a.Ghz5() {
out.WriteString("Ghz5,")
}
if a.Passive() {
out.WriteString("Passive,")
}
if a.Dynamic() {
out.WriteString("Dynamic,")
}
if a.GFSK() {
out.WriteString("GFSK,")
}
if length := out.Len(); length > 0 {
return string(out.Bytes()[:length-1]) // strip final comma
}
return ""
}
func (options *xml2) ListItem(out *bytes.Buffer, text []byte, flags int) {
if flags&_LIST_TYPE_DEFINITION != 0 && flags&_LIST_TYPE_TERM == 0 {
out.Write(text)
return
}
if flags&_LIST_TYPE_TERM != 0 {
if flags&_LIST_ITEM_BEGINNING_OF_LIST == 0 {
out.WriteString("</t>\n")
}
// close previous one?/
out.WriteString("<t hangText=\"")
n := out.Len()
writeSanitizeXML(out, text)
if n == out.Len() {
printf(nil, "no text remained after sanitizing XML for definition term: '"+string(text)+"'")
}
out.WriteString("\">\n")
out.WriteString("<vspace />\n") // Align HTML and XML2 output, but inserting a new line (vspace here)
return
}
out.WriteString("<t>")
out.Write(text)
out.WriteString("</t>\n")
options.paraInList = false
}
func predString(tv TypeAndValue) string {
var buf bytes.Buffer
pred := func(b bool, s string) {
if b {
if buf.Len() > 0 {
buf.WriteString(", ")
}
buf.WriteString(s)
}
}
pred(tv.IsVoid(), "void")
pred(tv.IsType(), "type")
pred(tv.IsBuiltin(), "builtin")
pred(tv.IsValue() && tv.Value != nil, "const")
pred(tv.IsValue() && tv.Value == nil, "value")
pred(tv.IsNil(), "nil")
pred(tv.Addressable(), "addressable")
pred(tv.Assignable(), "assignable")
pred(tv.HasOk(), "hasOk")
if buf.Len() == 0 {
return "invalid"
}
return buf.String()
}
// String provides a human readable string for Dot11Flags.
// This string is possibly subject to change over time; if you're storing this
// persistently, you should probably store the Dot11Flags value, not its string.
func (a Dot11Flags) String() string {
var out bytes.Buffer
if a.ToDS() {
out.WriteString("TO-DS,")
}
if a.FromDS() {
out.WriteString("FROM-DS,")
}
if a.MF() {
out.WriteString("MF,")
}
if a.Retry() {
out.WriteString("Retry,")
}
if a.PowerManagement() {
out.WriteString("PowerManagement,")
}
if a.MD() {
out.WriteString("MD,")
}
if a.WEP() {
out.WriteString("WEP,")
}
if a.Order() {
out.WriteString("Order,")
}
if length := out.Len(); length > 0 {
return string(out.Bytes()[:length-1]) // strip final comma
}
return ""
}
// HTML renders HTML content and sends it back to the HTTP client.
func HTML(w http.ResponseWriter, opts Options) error {
if w == nil {
return ErrNilResponseWriter
}
if opts.Template == nil {
return ErrNilHTMLTemplate
}
headers := w.Header()
headers.Set("Content-Type", "text/html; charset=utf-8")
maxAge := strconv.FormatFloat(opts.STSMaxAge.Seconds(), 'f', -1, 64)
headers.Set("Strict-Transport-Security", "max-age="+maxAge)
headers.Set("X-Frame-Options", "SAMEORIGIN")
headers.Set("X-XSS-Protection", "1; mode=block")
headers.Set("X-Content-Type-Options", "nosniff")
cache(headers, opts)
if opts.Status <= 0 {
opts.Status = http.StatusOK
}
buf := new(bytes.Buffer)
if err := opts.Template.Execute(buf, opts.Data); err != nil {
log.Printf("[ERROR] %v", err)
}
headers.Set("Content-Length", strconv.Itoa(buf.Len()))
w.WriteHeader(opts.Status)
w.Write(buf.Bytes())
return nil
}
func helperDoubleEmphasis(p *parser, out *bytes.Buffer, data []byte, c byte) int {
i := 0
for i < len(data) {
length := helperFindEmphChar(data[i:], c)
if length == 0 {
return 0
}
i += length
if i+1 < len(data) && data[i] == c && data[i+1] == c && i > 0 && !isspace(data[i-1]) {
var work bytes.Buffer
p.inline(&work, data[:i])
if work.Len() > 0 {
// pick the right renderer
if c == '~' {
p.r.StrikeThrough(out, work.Bytes())
} else {
p.r.DoubleEmphasis(out, work.Bytes())
}
}
return i + 2
}
i++
}
return 0
}
// Write writes data to the connection.
// net.Conn Deadlines are ignored. net.Conn concurrency semantics are supported.
func (meek *MeekConn) Write(buffer []byte) (n int, err error) {
if meek.closed() {
return 0, ContextError(errors.New("meek connection is closed"))
}
// Repeats until all n bytes are written
n = len(buffer)
for len(buffer) > 0 {
// Block until there is capacity in the send buffer
var sendBuffer *bytes.Buffer
select {
case sendBuffer = <-meek.emptySendBuffer:
case sendBuffer = <-meek.partialSendBuffer:
case <-meek.broadcastClosed:
return 0, ContextError(errors.New("meek connection has closed"))
}
writeLen := MAX_SEND_PAYLOAD_LENGTH - sendBuffer.Len()
if writeLen > 0 {
if writeLen > len(buffer) {
writeLen = len(buffer)
}
_, err = sendBuffer.Write(buffer[:writeLen])
buffer = buffer[writeLen:]
}
meek.replaceSendBuffer(sendBuffer)
}
return n, err
}
func TestReadWriteBinary(t *testing.T) {
f := New(1000, 4)
var buf bytes.Buffer
bytesWritten, err := f.WriteTo(&buf)
if err != nil {
t.Fatal(err.Error())
}
if bytesWritten != int64(buf.Len()) {
t.Errorf("incorrect write length %d != %d", bytesWritten, buf.Len())
}
var g BloomFilter
bytesRead, err := g.ReadFrom(&buf)
if err != nil {
t.Fatal(err.Error())
}
if bytesRead != bytesWritten {
t.Errorf("read unexpected number of bytes %d != %d", bytesRead, bytesWritten)
}
if g.m != f.m {
t.Error("invalid m value")
}
if g.k != f.k {
t.Error("invalid k value")
}
if g.b == nil {
t.Fatal("bitset is nil")
}
if !g.b.Equal(f.b) {
t.Error("bitsets are not equal")
}
}
// Encode encodes the values into ``URL encoded'' form
// ("acl&bar=baz&foo=quux") sorted by key.
func Encode(v url.Values) string {
if v == nil {
return ""
}
var buf bytes.Buffer
keys := make([]string, 0, len(v))
for k := range v {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
vs := v[k]
prefix := url.QueryEscape(k)
for _, v := range vs {
if buf.Len() > 0 {
buf.WriteByte('&')
}
buf.WriteString(prefix)
if v != "" {
buf.WriteString("=")
buf.WriteString(url.QueryEscape(v))
}
}
}
return buf.String()
}
func comma(s string) string {
var buf bytes.Buffer
parts := strings.Split(s, ".")
pos := 0
if len(parts[0])%3 != 0 {
pos += len(parts[0]) % 3
fmt.Println("ACK " + parts[0][:pos])
buf.WriteString(parts[0][:pos])
buf.Write([]byte{','})
}
for ; pos < len(parts[0]); pos += 3 {
buf.WriteString(parts[0][pos : pos+3])
buf.Write([]byte{','})
}
buf.Truncate(buf.Len() - 1)
if len(parts) > 1 {
buf.Write([]byte{'.'})
buf.WriteString(parts[1])
}
return buf.String()
}
// TODO: This is probably broken
func (r *roffRenderer) TableCell(out *bytes.Buffer, text []byte, align int) {
if out.Len() > 0 {
out.WriteString("\t")
}
out.Write(text)
out.WriteString("\t")
}
func RunTestLZW(data []byte) {
log.Printf("encoding/RunTestLZW: Testing comprssion LZW\n")
var compressed bytes.Buffer
w := lzw.NewWriter(&compressed, lzw.MSB, 8)
defer w.Close()
now := time.Now()
w.Write(data)
cl := compressed.Len()
log.Printf("encoding/RunTestLZW: Compressed from %d bytes to %d bytes in %d ns\n", len(data), cl, time.Since(now).Nanoseconds())
recovered := make([]byte, len(data))
r := lzw.NewReader(&compressed, lzw.MSB, 8)
defer r.Close()
total := 0
n := 100
var err error = nil
for err != io.EOF && n != 0 {
n, err = r.Read(recovered[total:])
total += n
}
log.Printf("encoding/RunTestLZW: Uncompressed from %d bytes to %d bytes in %d ns\n", cl, len(recovered), time.Since(now).Nanoseconds())
}
func saveDraw(w *draw.Window, statusCh chan string) {
var buffer bytes.Buffer
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
panic(err)
}
buffer.WriteString(dir)
statusCh <- fmt.Sprintf("Choose a Filename: %s", buffer.String())
for {
ev := termbox.PollEvent()
switch ev.Key {
case termbox.KeyEnter:
statusCh <- "Saved"
return
case termbox.KeyBackspace:
if buffer.Len() > 0 {
buffer.Truncate(buffer.Len() - 1)
}
default:
buffer.WriteRune(ev.Ch)
}
statusCh <- fmt.Sprintf("Choose a Filename: %s", buffer.String())
}
}
func (s *ESAPIV0) Bulk(data *bytes.Buffer) {
if data == nil || data.Len() == 0 {
return
}
data.WriteRune('\n')
url := fmt.Sprintf("%s/_bulk", s.Host)
client := &http.Client{}
reqest, _ := http.NewRequest("POST", url, data)
if s.Auth != nil {
reqest.SetBasicAuth(s.Auth.User, s.Auth.Pass)
}
resp, errs := client.Do(reqest)
if errs != nil {
log.Error(errs)
return
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Error(err)
return
}
log.Trace(url, string(body))
defer resp.Body.Close()
defer data.Reset()
if resp.StatusCode != 200 {
log.Errorf("bad bulk response: %s %s", body, resp.StatusCode)
return
}
}
func TestProgressWriterIgnoreTotal(t *testing.T) {
filename := "progress_test.go"
f, err := os.Open(filename)
defer f.Close()
if err != nil {
log.Fatalln(err)
}
fs, err := os.Stat(filename)
if err != nil {
log.Fatalln(err)
}
p := New()
p.IgnoreTotal = true
p.Progress = func(current, total, expected int64) {
log.Println("Ignore total writing", current, total, expected)
assert.Equal(t, true, current >= total)
}
b := new(bytes.Buffer)
w := io.MultiWriter(p, b)
_, err = io.Copy(w, f)
if err != nil {
log.Fatalln(err)
}
assert.Equal(t, fs.Size(), int64(b.Len()))
}
func TestBzip2(t *testing.T) {
var compressed, uncompressed bytes.Buffer
w := bzip.NewWriter(&compressed)
// Write a repetitive message in a million pieces,
// compressing one copy but not the other.
tee := io.MultiWriter(w, &uncompressed)
for i := 0; i < 1000000; i++ {
io.WriteString(tee, "hello")
}
if err := w.Close(); err != nil {
t.Fatal(err)
}
// Check the size of the compressed stream.
if got, want := compressed.Len(), 255; got != want {
t.Errorf("1 million hellos compressed to %d bytes, want %d", got, want)
}
// Decompress and compare with original.
var decompressed bytes.Buffer
io.Copy(&decompressed, bzip2.NewReader(&compressed))
if !bytes.Equal(uncompressed.Bytes(), decompressed.Bytes()) {
t.Error("decompression yielded a different message")
}
}
func (options *Html) Header(out *bytes.Buffer, text func() bool, level int, id string) {
marker := out.Len()
doubleSpace(out)
if id != "" {
out.WriteString(fmt.Sprintf("<h%d id=\"%s\">", level, id))
} else if options.flags&HTML_TOC != 0 {
// headerCount is incremented in htmlTocHeader
out.WriteString(fmt.Sprintf("<h%d id=\"toc_%d\">", level, options.headerCount))
} else {
out.WriteString(fmt.Sprintf("<h%d>", level))
}
tocMarker := out.Len()
if !text() {
out.Truncate(marker)
return
}
// are we building a table of contents?
if options.flags&HTML_TOC != 0 {
options.TocHeaderWithAnchor(out.Bytes()[tocMarker:], level, id)
}
out.WriteString(fmt.Sprintf("</h%d>\n", level))
}
func (dr *DataRecord) Unmarshal(r io.Reader, fss FieldSpecifiers, t *Translate) error {
// We don't know how many records there are in a Data Set, so we'll keep
// reading until we exhausted the buffer.
buffer := new(bytes.Buffer)
if _, err := buffer.ReadFrom(r); err != nil {
return err
}
dr.Fields = make(Fields, 0)
var err error
for i := 0; buffer.Len() > 0 && i < len(fss); i++ {
f := Field{
Type: fss[i].Type,
Length: fss[i].Length,
}
if err = f.Unmarshal(buffer); err != nil {
return err
}
dr.Fields = append(dr.Fields, f)
}
if t != nil && len(dr.Fields) > 0 {
if err := t.Record(dr); err != nil {
return err
}
}
return nil
}