func writeSuccessResponseHeader(w *bufio.Writer, opcode uint8, keyLength, extraLength,
totalBodyLength int, opaque uint32, flush bool) error {
header := resHeadPool.Get().(ResponseHeader)
header.Magic = MagicResponse
header.Opcode = opcode
header.KeyLength = uint16(keyLength)
header.ExtraLength = uint8(extraLength)
header.DataType = uint8(0)
header.Status = StatusSuccess
header.TotalBodyLength = uint32(totalBodyLength)
header.OpaqueToken = opaque
header.CASToken = uint64(0)
if err := writeResponseHeader(w, header); err != nil {
resHeadPool.Put(header)
return err
}
if flush {
if err := w.Flush(); err != nil {
resHeadPool.Put(header)
return err
}
}
metrics.IncCounterBy(common.MetricBytesWrittenRemote, resHeaderLen)
resHeadPool.Put(header)
return nil
}
func writeBodyFixedSize(w *bufio.Writer, r io.Reader, size int64) error {
if size > maxSmallFileSize {
// w buffer must be empty for triggering
// sendfile path in bufio.Writer.ReadFrom.
if err := w.Flush(); err != nil {
return err
}
}
// Unwrap a single limited reader for triggering sendfile path
// in net.TCPConn.ReadFrom.
lr, ok := r.(*io.LimitedReader)
if ok {
r = lr.R
}
n, err := copyZeroAlloc(w, r)
if ok {
lr.N -= n
}
if n != size && err == nil {
err = fmt.Errorf("copied %d bytes from body stream instead of %d bytes", n, size)
}
return err
}
func (r Resolver) outputResults(w *bufio.Writer, results gresults) {
var zip, city, state, stateName, county, country, countryName string
var latitude, longitude float32
var comp addressComponent
var err error
for _, res := range results.Results {
if comp, err = res.findAddressComponent(zipType); err == nil {
zip = comp.LongName
}
if comp, err = res.findAddressComponent(cityType); err == nil {
city = comp.LongName
}
if comp, err = res.findAddressComponent(countyType); err == nil {
county = comp.LongName
}
if comp, err = res.findAddressComponent(stateType); err == nil {
state = strings.ToUpper(comp.ShortName)
stateName = comp.LongName
}
if comp, err = res.findAddressComponent(countryType); err == nil {
country = strings.ToUpper(comp.ShortName)
countryName = comp.LongName
}
latitude = res.Geometry.Location.Lat
longitude = res.Geometry.Location.Lng
}
w.WriteString(fmt.Sprintf("%v,\"%v\",\"%v\",\"%v\",\"%v\",\"%v\",\"%v\",%v,%v\n", country, zip, city, state, stateName, county, countryName, latitude, longitude))
w.Flush()
}
// NewStreamReader returns a reader, which replays all the data generated by sw.
//
// The returned reader may be passed to Response.SetBodyStream.
//
// Close must be called on the returned reader after all the required data
// has been read. Otherwise goroutine leak may occur.
//
// See also Response.SetBodyStreamWriter.
func NewStreamReader(sw StreamWriter) io.ReadCloser {
pc := fasthttputil.NewPipeConns()
pw := pc.Conn1()
pr := pc.Conn2()
var bw *bufio.Writer
v := streamWriterBufPool.Get()
if v == nil {
bw = bufio.NewWriter(pw)
} else {
bw = v.(*bufio.Writer)
bw.Reset(pw)
}
go func() {
defer func() {
if r := recover(); r != nil {
defaultLogger.Printf("panic in StreamWriter: %s\nStack trace:\n%s", r, debug.Stack())
}
}()
sw(bw)
bw.Flush()
pw.Close()
streamWriterBufPool.Put(bw)
}()
return pr
}
// authenticate authenticates ourselves with the X server.
// displayStr is the "12" out of ":12.0".
func authenticate(w *bufio.Writer, displayStr string) os.Error {
key, value, err := readAuth(displayStr)
if err != nil {
return err
}
// Assume that the authentication protocol is "MIT-MAGIC-COOKIE-1".
if len(key) != 18 || len(value) != 16 {
return os.NewError("unsupported Xauth")
}
// 0x006c means little-endian. 0x000b, 0x0000 means X major version 11, minor version 0.
// 0x0012 and 0x0010 means the auth key and value have lengths 18 and 16.
// The final 0x0000 is padding, so that the string length is a multiple of 4.
_, err = io.WriteString(w, "\x6c\x00\x0b\x00\x00\x00\x12\x00\x10\x00\x00\x00")
if err != nil {
return err
}
_, err = io.WriteString(w, key)
if err != nil {
return err
}
// Again, the 0x0000 is padding.
_, err = io.WriteString(w, "\x00\x00")
if err != nil {
return err
}
_, err = io.WriteString(w, value)
if err != nil {
return err
}
err = w.Flush()
if err != nil {
return err
}
return nil
}
func (c *DefaultServerCodec) WriteResponse(wr *bufio.Writer, proto *Proto) (err error) {
log.Debug("write proto: %v", proto)
// packlen =header(16) + body
if err = binary.Write(wr, binary.BigEndian, uint32(rawHeaderLen)+uint32(len(proto.Body))); err != nil {
log.Error("packLen: binary.Write() error(%v)", err)
return
}
if err = binary.Write(wr, binary.BigEndian, rawHeaderLen); err != nil {
log.Error("headerLen: binary.Write() error(%v)", err)
return
}
if err = binary.Write(wr, binary.BigEndian, proto.Ver); err != nil {
log.Error("protoVer: binary.Write() error(%v)", err)
return
}
if err = binary.Write(wr, binary.BigEndian, proto.Operation); err != nil {
log.Error("operation: binary.Write() error(%v)", err)
return
}
if err = binary.Write(wr, binary.BigEndian, proto.SeqId); err != nil {
log.Error("seqId: binary.Write() error(%v)", err)
return
}
if proto.Body != nil {
if _, err = wr.Write(proto.Body); err != nil {
log.Error("body: wr.Write() error(%v)", err)
return
}
}
return wr.Flush()
}
// Write writes response to w.
//
// Write doesn't flush response to w for performance reasons.
func (resp *Response) Write(w *bufio.Writer) error {
var err error
if resp.bodyStream != nil {
contentLength := resp.Header.ContentLength()
if contentLength >= 0 {
if err = resp.Header.Write(w); err != nil {
return err
}
if err = writeBodyFixedSize(w, resp.bodyStream, contentLength); err != nil {
return err
}
} else {
resp.Header.SetContentLength(-1)
if err = resp.Header.Write(w); err != nil {
return err
}
if err = writeBodyChunked(w, resp.bodyStream); err != nil {
return err
}
}
if bsc, ok := resp.bodyStream.(io.Closer); ok {
err = bsc.Close()
}
return err
}
resp.Header.SetContentLength(len(resp.body))
if err = resp.Header.Write(w); err != nil {
return err
}
_, err = w.Write(resp.body)
return err
}
func doWriteRune(w *bufio.Writer) {
if written, err := w.WriteRune(rune('o')); err != nil {
log.Fatalf("failed writing a rune: %s", err)
} else {
log.Printf("Wrote rune in %d bytes", written)
}
}
func doWriteString(w *bufio.Writer) {
if written, err := w.WriteString(", The Standard Library\n"); err != nil {
log.Fatalf("failed writing string: %s", err)
} else {
log.Printf("Wrote string in %d bytes", written)
}
}
func emit_allele_path_item(ofp *bufio.Writer) {
for k := range g_allele_path_item {
for i := 0; i < len(g_allele_path_item[k]); i++ {
s := fmt.Sprintf("%d,%d,%d,%d,%d,%s\n",
g_allele_path_item[k][i].AlleleId,
g_allele_path_item[k][i].PathItemIndex,
g_allele_path_item[k][i].SequenceId,
g_allele_path_item[k][i].Start,
g_allele_path_item[k][i].Length,
g_allele_path_item[k][i].StrandIsForward)
ofp.Write([]byte(s))
}
}
return
for allele_name := range g_allele_sequenceid_path {
allele_id := g_allele_name_id_map[allele_name]
for i := 0; i < len(g_allele_sequenceid_path[allele_name]); i++ {
seqid := g_allele_sequenceid_path[allele_name][i]
s := fmt.Sprintf("%d,%d,%d,%s,%s,%s\n", allele_id, i, seqid, "NULL", "NULL", "'TRUE'")
ofp.Write([]byte(s))
}
}
}
// Write writes request to w.
//
// Write doesn't flush request to w for performance reasons.
func (req *Request) Write(w *bufio.Writer) error {
if len(req.Header.Host()) == 0 {
uri := req.URI()
host := uri.Host()
if len(host) == 0 {
return errRequestHostRequired
}
req.Header.SetHostBytes(host)
req.Header.SetRequestURIBytes(uri.RequestURI())
}
body := req.body
var err error
if req.multipartForm != nil && len(req.body) == 0 {
body, err = marshalMultipartForm(req.multipartForm, req.multipartFormBoundary)
if err != nil {
return fmt.Errorf("error when marshaling multipart form: %s", err)
}
req.Header.SetMultipartFormBoundary(req.multipartFormBoundary)
}
hasBody := !req.Header.noBody()
if hasBody {
req.Header.SetContentLength(len(body))
}
if err = req.Header.Write(w); err != nil {
return err
}
if hasBody {
_, err = w.Write(body)
} else if len(body) > 0 {
return fmt.Errorf("Non-zero body for non-POST request. body=%q", body)
}
return err
}
func writeln(w *bufio.Writer, s string) error {
_, err := w.WriteString(s)
if err != nil {
return err
}
return newLine(w)
}
// Function IHex.Write writes the representation of the file to the writer `wr`.
func (ix *IHex) Write(wr *bufio.Writer) (err error) {
for start, data := range ix.areas {
i := 0
for i < len(data) {
var chunk []byte
if i+16 <= len(data) {
chunk = data[i : i+16]
} else {
chunk = data[i:]
}
_, err := wr.Write([]byte(makeLine(0x00, start, chunk)))
if err != nil {
return err
}
start += 16
}
}
_, err = wr.Write([]byte(makeLine(0x01, 0, []byte{})))
if err != nil {
return err
}
return nil
}
func writeErrorResponseHeader(w *bufio.Writer, opcode uint8, status uint16, opaque uint32) error {
header := resHeadPool.Get().(ResponseHeader)
header.Magic = MagicResponse
header.Opcode = opcode
header.KeyLength = uint16(0)
header.ExtraLength = uint8(0)
header.DataType = uint8(0)
header.Status = status
header.TotalBodyLength = uint32(0)
header.OpaqueToken = opaque
header.CASToken = uint64(0)
if err := writeResponseHeader(w, header); err != nil {
resHeadPool.Put(header)
return err
}
if err := w.Flush(); err != nil {
resHeadPool.Put(header)
return err
}
metrics.IncCounterBy(common.MetricBytesWrittenRemote, resHeaderLen)
resHeadPool.Put(header)
return nil
}
func (t *TcpPlayer) sendUpdates(w *bufio.Writer, wg *sync.WaitGroup) {
defer wg.Done()
enc := json.NewEncoder(w)
lastTurnSent := -1
for update := range t.update {
t.stateL.Lock()
t.state = update
t.stateL.Unlock()
if update.Turn == lastTurnSent {
continue
}
if err := enc.Encode(update); err != nil {
t.l.Errorf("[TCP] sending update to player, %v", err)
return
}
if _, err := w.WriteRune('\n'); err != nil {
t.l.Errorf("[TCP] sending EOL to player, %v", err)
return
}
if err := w.Flush(); err != nil {
t.l.Errorf("[TCP] flushing update to player, %v", err)
return
}
lastTurnSent = update.Turn
}
}
func writeBase64String(s string, b *bufio.Writer, f *Format) {
b.WriteRune('|')
w := base64.NewEncoder(base64.StdEncoding, b)
w.Write([]byte(s))
w.Close()
b.WriteRune('|')
}
// writeTo serializes the processing instruction to the writer.
func (p *ProcInst) writeTo(w *bufio.Writer) {
w.WriteString("<?")
w.WriteString(p.Target)
w.WriteByte(' ')
w.WriteString(p.Inst)
w.WriteString("?>")
}
// Write Bind Response PDU
func (pdu *PDUBindResp) write(w *bufio.Writer) (err os.Error) {
// Write Header
err = pdu.Header.write(w)
if err != nil {
err = os.NewError("Bind Response: Error writing Header")
return
}
// Create byte array the size of the PDU
p := make([]byte, pdu.Header.CmdLength-pdu.OptionalLen-16)
pos := 0
// Copy system id
if len(pdu.SystemId) > 0 {
copy(p[pos:len(pdu.SystemId)], []byte(pdu.SystemId))
pos += len(pdu.SystemId)
}
pos++ // Null terminator
// Write to buffer
_, err = w.Write(p)
if err != nil {
err = os.NewError("Bind Response: Error writing to buffer")
return
}
// Flush write buffer
err = w.Flush()
if err != nil {
err = os.NewError("Bind Response: Error flushing write buffer")
}
// Optional params
err = pdu.writeOptional(w)
if err != nil {
err = os.NewError("Bind Response: Error writing optional params")
}
return
}
func WriteProto(wr *bufio.Writer, proto *Proto) (err error) {
// write
if err = binary.Write(wr, binary.BigEndian, uint32(rawHeaderLen)+uint32(len(proto.Body))); err != nil {
return
}
if err = binary.Write(wr, binary.BigEndian, rawHeaderLen); err != nil {
return
}
if err = binary.Write(wr, binary.BigEndian, proto.Ver); err != nil {
return
}
if err = binary.Write(wr, binary.BigEndian, proto.Operation); err != nil {
return
}
if err = binary.Write(wr, binary.BigEndian, proto.SeqId); err != nil {
return
}
if proto.Body != nil {
log.Debug("cipher body: %v", proto.Body)
if err = binary.Write(wr, binary.BigEndian, proto.Body); err != nil {
return
}
}
err = wr.Flush()
return
}
// Write Optional param
func (op *pduOptParam) write(w *bufio.Writer) (err os.Error) {
// Create byte array
p := make([]byte, 4+op.length)
copy(p[0:2], packUint(uint64(op.tag), 2))
copy(p[2:4], packUint(uint64(op.length), 2))
// Determine data type of value
v := reflect.NewValue(op.value)
switch t := v.(type) {
case *reflect.StringValue:
copy(p[4:op.length], []byte(op.value.(string)))
case *reflect.Uint8Value:
p[4] = byte(op.value.(uint8))
case *reflect.Uint16Value:
copy(p[4:6], packUint(uint64(op.value.(uint16)), 2))
case *reflect.Uint32Value:
copy(p[4:8], packUint(uint64(op.value.(uint32)), 4))
}
// Write to buffer
_, err = w.Write(p)
if err != nil {
return
}
// Flush write buffer
err = w.Flush()
return
}
func writeToStderr(msg string, errWriter *bufio.Writer) {
if !strings.HasSuffix(msg, "\n") {
msg = msg + "\n"
}
errWriter.WriteString(msg)
errWriter.Flush()
}
func main() {
flag.Parse()
checkFlags()
var csvWriter *bufio.Writer
if *csvFile != "" {
f, err := os.Create(*csvFile)
if err != nil {
log.Fatal(err)
}
defer f.Close()
csvWriter = bufio.NewWriter(f)
defer csvWriter.Flush()
}
isFirstFile := true
if *multiple {
// Process multiple history files
filepath.Walk(*input, func(filePath string, f os.FileInfo, err error) error {
if filePath == *input {
return nil
}
fmt.Println("Processing ", filePath, "...")
result := processFile(filePath, csvWriter, isFirstFile)
fmt.Println(result)
isFirstFile = false
return nil
})
} else {
result := processFile(*input, csvWriter, isFirstFile)
fmt.Println(result)
}
}
func new_line(fw *bufio.Writer, email string, dest string) {
pad := 40 - len(email)
if pad <= 0 {
pad = 1
}
fw.WriteString(email + strings.Repeat(" ", pad) + dest + "\n")
}
func HandshakeSample(c net.Conn, br *bufio.Reader, bw *bufio.Writer, timeout time.Duration) (err error) {
defer func() {
if r := recover(); r != nil {
err = r.(error)
}
}()
// Send C0+C1
err = bw.WriteByte(0x03)
c1 := CreateRandomBlock(RTMP_SIG_SIZE)
for i := 0; i < 8; i++ {
c1[i] = 0
}
bw.Write(c1)
err = bw.Flush()
CheckError(err, "Handshake() Flush C0+C1")
// Read S0+S1+S2
s0, err := br.ReadByte()
CheckError(err, "Handshake() Read S0")
if s0 != 0x03 {
return errors.New(fmt.Sprintf("Handshake() Got S0: %x", s0))
}
s1 := make([]byte, RTMP_SIG_SIZE)
_, err = io.ReadAtLeast(br, s1, RTMP_SIG_SIZE)
CheckError(err, "Handshake() Read S1")
bw.Write(s1)
err = bw.Flush()
CheckError(err, "Handshake() Flush C2")
_, err = io.ReadAtLeast(br, s1, RTMP_SIG_SIZE)
CheckError(err, "Handshake() Read S2")
return
}
func (conn *Connection) writer() {
var w *bufio.Writer
var err error
for {
var packet []byte
select {
case packet = <-conn.packets:
default:
if w = conn.w; w != nil {
if err := w.Flush(); err != nil {
conn.closeConnection(err)
}
}
select {
case packet = <-conn.packets:
case <-conn.control:
return
}
}
if packet == nil {
return
}
if w = conn.w; w == nil {
if _, w, err = conn.createConnection(); err != nil {
return
}
}
if err := write(w, packet); err != nil {
conn.closeConnection(err)
continue
}
}
}
func tokenize(bf2 *bufio.Reader, bf3 *bufio.Writer) {
for s, err := bf2.ReadString('\n'); err == nil; s, err = bf2.ReadString('\n') {
fs := strings.Split(s, "\t")
doc, _ := NewDocument(fs[0])
doc.SetInput("T", fs[1])
doc.SetInput("A", fs[2])
doc.Tokenize()
doc.AssembleSentences()
var soffs []string
sents := doc.SectionSentences("T")
for _, sent := range sents {
soffs = append(soffs, fmt.Sprintf("%d:%d", sent.Begin(), sent.End()))
}
bf3.WriteString(fmt.Sprintf("%s\t%s\t", fs[0], strings.Join(soffs, ",")))
soffs = soffs[:0]
sents = doc.SectionSentences("A")
for _, sent := range sents {
soffs = append(soffs, fmt.Sprintf("%d:%d", sent.Begin(), sent.End()))
}
bf3.WriteString(fmt.Sprintf("%s\n", strings.Join(soffs, ",")))
}
}
func writeHeader(output *bufio.Writer) {
if *verbose && !*dryRun {
fmt.Println("Writing source header")
}
licensePath := pathutils.Join(*projectPath, "GPL3-header.txt")
license, err := os.Open(licensePath)
if err != nil {
panic(err)
}
defer func() {
if err := license.Close(); err != nil {
panic(err)
}
}()
reader := bufio.NewReader(license)
for {
if *verbose {
fmt.Printf("Got line: '%s'\n")
}
line, err := reader.ReadString('\n')
if err != nil {
if err != io.EOF {
panic(err)
}
}
fmt.Fprintf(output, "// %s", line)
if err == io.EOF {
break
}
}
output.WriteString("\n//\n")
output.Flush()
}
func SendHandshakeResponse(writer *bufio.Writer, status byte) (err error) {
_, err = writer.Write([]byte{0x05, status})
if err != nil {
return
}
return writer.Flush()
}
// sendResponse send resp to client, sendResponse must be goroutine safe.
func (server *Server) writeTCPResponse(wr *bufio.Writer, proto *Proto) (err error) {
if Conf.Debug {
log.Debug("write proto: %v", proto)
}
if err = ioutil.WriteBigEndianInt32(wr, int32(rawHeaderLen)+int32(len(proto.Body))); err != nil {
return
}
if err = ioutil.WriteBigEndianInt16(wr, rawHeaderLen); err != nil {
return
}
if err = ioutil.WriteBigEndianInt16(wr, proto.Ver); err != nil {
return
}
if err = ioutil.WriteBigEndianInt32(wr, proto.Operation); err != nil {
return
}
if err = ioutil.WriteBigEndianInt32(wr, proto.SeqId); err != nil {
return
}
if proto.Body != nil {
if _, err = wr.Write(proto.Body); err != nil {
return
}
}
if err = wr.Flush(); err != nil {
log.Error("tcp wr.Flush() error(%v)", err)
}
proto.Reset()
return
}
func (l BList) renderBCode(w *bufio.Writer) {
w.WriteString("l")
for i := range l {
l[i].renderBCode(w)
}
w.WriteString("e")
}