// bigIntToNetIPv6 is a helper function that correctly returns a net.IP with the // correctly padded values. func bigIntToNetIPv6(bi *big.Int) *net.IP { x := make(net.IP, IPv6len) ipv6Bytes := bi.Bytes() // It's possibe for ipv6Bytes to be less than IPv6len bytes in size. If // they are different sizes we to pad the size of response. if len(ipv6Bytes) < IPv6len { buf := new(bytes.Buffer) buf.Grow(IPv6len) for i := len(ipv6Bytes); i < IPv6len; i++ { if err := binary.Write(buf, binary.BigEndian, byte(0)); err != nil { panic(fmt.Sprintf("Unable to pad byte %d of input %v: %v", i, bi, err)) } } for _, b := range ipv6Bytes { if err := binary.Write(buf, binary.BigEndian, b); err != nil { panic(fmt.Sprintf("Unable to preserve endianness of input %v: %v", bi, err)) } } ipv6Bytes = buf.Bytes() } i := copy(x, ipv6Bytes) if i != IPv6len { panic("IPv6 wrong size") } return &x }
func (obj GCAddEffectPacket) Write(buf io.Writer, code uint8) error { binary.Write(buf, binary.LittleEndian, obj.ObjectID) binary.Write(buf, binary.LittleEndian, obj.EffectID) binary.Write(buf, binary.LittleEndian, obj.Duration) return nil }
func (e *indexEntry) WriteTo(w io.Writer) (n int64, err error) { deleted := byte(0) if e.deleted { deleted = 1 } if err = binary.Write(w, binary.BigEndian, deleted); err != nil { return 0, err } value_len := uint32(len(e.value)) if err = binary.Write(w, binary.BigEndian, value_len); err != nil { return 0, err } if err = binary.Write(w, binary.BigEndian, []byte(e.value)); err != nil { return 0, err } if err = binary.Write(w, binary.BigEndian, e.id); err != nil { return 0, err } return int64(binary.Size(deleted) + binary.Size([]byte(e.value)) + binary.Size(e.id)), nil }
func (client *Client) WriteEMessage(emsg *EMessage) []byte { buffer := new(bytes.Buffer) binary.Write(buffer, binary.BigEndian, emsg.msgid) binary.Write(buffer, binary.BigEndian, emsg.device_id) SendMessage(buffer, emsg.msg) return buffer.Bytes() }
func serializeV1PrecertSCTSignatureInput(timestamp uint64, issuerKeyHash [issuerKeyHashLength]byte, tbs []byte, ext CTExtensions) ([]byte, error) { if err := checkCertificateFormat(tbs); err != nil { return nil, err } if err := checkExtensionsFormat(ext); err != nil { return nil, err } var buf bytes.Buffer if err := binary.Write(&buf, binary.BigEndian, V1); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, CertificateTimestampSignatureType); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, timestamp); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, PrecertLogEntryType); err != nil { return nil, err } if _, err := buf.Write(issuerKeyHash[:]); err != nil { return nil, err } if err := writeVarBytes(&buf, tbs, CertificateLengthBytes); err != nil { return nil, err } if err := writeVarBytes(&buf, ext, ExtensionsLengthBytes); err != nil { return nil, err } return buf.Bytes(), nil }
// SerializeTimestampedEntry writes timestamped entry to Writer. // In case of error, w may contain garbage. func SerializeTimestampedEntry(w io.Writer, t *TimestampedEntry) error { if err := binary.Write(w, binary.BigEndian, t.Timestamp); err != nil { return err } if err := binary.Write(w, binary.BigEndian, t.EntryType); err != nil { return err } switch t.EntryType { case X509LogEntryType: if err := writeVarBytes(w, t.X509Entry, CertificateLengthBytes); err != nil { return err } case PrecertLogEntryType: if err := binary.Write(w, binary.BigEndian, t.PrecertEntry.IssuerKeyHash); err != nil { return err } if err := writeVarBytes(w, t.PrecertEntry.TBSCertificate, PreCertificateLengthBytes); err != nil { return err } case XJSONLogEntryType: // TODO: Pending google/certificate-transparency#1243, replace // with ObjectHash once supported by CT server. //jsonhash := objecthash.CommonJSONHash(string(t.JSONData)) if err := writeVarBytes(w, []byte(t.JSONData), JSONLengthBytes); err != nil { return err } default: return fmt.Errorf("unknown EntryType: %d", t.EntryType) } writeVarBytes(w, t.Extensions, ExtensionsLengthBytes) return nil }
func MarshalPacket(pack interface{}) ([]byte, error) { et := typetest(pack) if et < EncodingTypeNil || et > EncodingTypeMax { return nil, errors.New("MarshalPacket unkown data type") } if encodingArray[et] == nil { return nil, errors.New("MarshalPacket unkown data type") } data, err := encodingArray[et].Marshal(pack) if err != nil { return nil, fmt.Errorf("%v %v", pack, err.Error()) } packetid, err := getPacketId(pack) if err != nil { return nil, fmt.Errorf("%v %v", pack, err.Error()) } ph := PacketHeader{ EncodeType: int16(et), PacketId: int16(packetid), } w := bytes.NewBuffer(nil) binary.Write(w, binary.LittleEndian, &ph) binary.Write(w, binary.LittleEndian, data) return w.Bytes(), nil }
func (this *DataPackage) Package() []byte { buf := new(bytes.Buffer) binary.Write(buf, binary.BigEndian, this.Head) binary.Write(buf, binary.BigEndian, this.Body) binary.Write(buf, binary.BigEndian, this.Tail) return buf.Bytes() }
func cipherPacket(cmd uint8, data []byte) []byte { buf := new(bytes.Buffer) binary.Write(buf, binary.BigEndian, cmd) binary.Write(buf, binary.BigEndian, uint16(len(data))) buf.Write(data) return buf.Bytes() }
func (w *Writer) flushIndex() error { w.trailer.DataIndexOffset = w.curOffset w.trailer.DataIndexCount = uint32(len(w.blocks)) w.fp.Write(IndexMagic) w.curOffset += uint64(len(IndexMagic)) for _, b := range w.blocks { if err := binary.Write(w.fp, binary.BigEndian, b.offset); err != nil { return err } w.curOffset += uint64(binary.Size(b.offset)) if err := binary.Write(w.fp, binary.BigEndian, b.size); err != nil { return err } w.curOffset += uint64(binary.Size(b.size)) if i, err := writeUvarint(w.fp, uint64(len(b.firstKeyBytes))); err != nil { return err } else { w.curOffset += uint64(i) } if i, err := w.fp.Write(b.firstKeyBytes); err != nil { return err } else { w.curOffset += uint64(i) } } return nil }
func (space *Space) Call(procName string, returnTuple bool, args ...TupleField) (tuples [][][]byte, err error) { body := new(bytes.Buffer) flags := BoxFlags if returnTuple == true { flags |= BoxReturnTuple } err = binary.Write(body, binary.LittleEndian, flags) if err != nil { return } err = String(procName).Pack(body) if err != nil { return } err = binary.Write(body, binary.LittleEndian, int32(len(args))) if err != nil { return } for _, field := range args { field.Pack(body) } tuples, err = space.request(CallOp, body) return }
// Refactor: same as Insert but Op number func (space *Space) Delete(tuple []TupleField, returnTuple bool) (tuples [][][]byte, err error) { body := new(bytes.Buffer) flags := BoxFlags if returnTuple == true { flags |= BoxReturnTuple } requestBody := []int32{space.spaceNo, flags} err = binary.Write(body, binary.LittleEndian, requestBody) if err != nil { return } err = binary.Write(body, binary.LittleEndian, int32(len(tuple))) if err != nil { return } for _, field := range tuple { field.Pack(body) } tuples, err = space.request(DeleteOp, body) return }
func (m *EntryBlockResponse) MarshalForSignature() ([]byte, error) { var buf primitives.Buffer binary.Write(&buf, binary.BigEndian, m.Type()) t := m.GetTimestamp() data, err := t.MarshalBinary() if err != nil { return nil, err } buf.Write(data) m.EBlockCount = uint32(len(m.EBlocks)) binary.Write(&buf, binary.BigEndian, m.EBlockCount) for _, eb := range m.EBlocks { bin, err := eb.MarshalBinary() if err != nil { return nil, err } buf.Write(bin) } m.EntryCount = uint32(len(m.Entries)) binary.Write(&buf, binary.BigEndian, m.EntryCount) for _, e := range m.Entries { bin, err := e.MarshalBinary() if err != nil { return nil, err } buf.Write(bin) } return buf.DeepCopyBytes(), nil }
func (move GCMovePacket) Write(buf io.Writer, code uint8) error { binary.Write(buf, binary.LittleEndian, move.ObjectID) binary.Write(buf, binary.LittleEndian, move.X) binary.Write(buf, binary.LittleEndian, move.Y) binary.Write(buf, binary.LittleEndian, move.Dir) return nil }
func (failed *GCSkillFailed1Packet) Write(buf io.Writer, code uint8) error { binary.Write(buf, binary.LittleEndian, failed.SkillType) binary.Write(buf, binary.LittleEndian, failed.Grade) failed.Dump(buf) return nil }
func writeNumber(b io.Writer, num int) (err error) { // The first two bits encode the size: // 00 = 1 byte // 01 = 2 bytes // 10 = 3 bytes // 11 = 4 bytes switch { case num < 64: // 2^(8-2) // Fits in one byte. binary.Write(b, binary.BigEndian, uint8(num)) case num < 16384: // 2^(16-2) // Fits in two bytes. binary.Write(b, binary.BigEndian, uint16(num|0x4000)) // Set the size to 01. case num < 4194304: // 2^(24-2) // Fits in three bytes. // Drop the two least significant bytes and set the size to 10. binary.Write(b, binary.BigEndian, uint8((num>>16)|0x80)) // Drop the two most significant bytes. binary.Write(b, binary.BigEndian, uint16(num&0xffff)) case num < 1073741824: // 2^(32-2): // Fits in four bytes. // Set the size to 11. binary.Write(b, binary.BigEndian, uint32(num|0xc0000000)) default: err = fmt.Errorf("Number is too big: %d", num) } return err }
// Writes the tny_page to the specified writer. We want to do this // in Go so that we can write a page to local disk, Hadoop, S3, etc func (self *TnyPage) WritePage(writer *bufio.Writer) { // Lets write out the page... // fmt.Printf("Writing page for %s (ptr: %p, len: %d):\n", self.Column.Name, self.cptr, self.Length()) if err := binary.Write(writer, binary.LittleEndian, int32(self.Depth())); err != nil { panic("Unable to write page header (depth) (" + err.Error() + ")") } if err := binary.Write(writer, binary.LittleEndian, int32(self.Length())); err != nil { panic("Unable to write page header (length) (" + err.Error() + ")") } // fmt.Printf("Wrote header, writing data now...\n") for d := 0; d < int(self.Depth()); d++ { bmp := self.BitmapAtDepth(d) bmpSlice := bmp.Slice() // fmt.Printf("\t%s\n", bmp.BitString(100)) // fmt.Printf("Writing slice %d...\n", d) if err := binary.Write(writer, binary.LittleEndian, bmpSlice); err != nil { panic("Unable to write page (" + err.Error() + ")") } } // fmt.Printf("Write Page (%d): ", depth) // for i := 0; i < 10; i++ { // fmt.Printf("%d, ", self.Access(i)) // } // fmt.Printf("\n") }
func (m *JointTrajectory) Serialize(w io.Writer) (err error) { if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil { return err } // Write size little endian err = binary.Write(w, binary.LittleEndian, uint32(len(m.JointNames))) if err != nil { return fmt.Errorf("could not write array length: %s", err) } for _, elem := range m.JointNames { if err = ros.SerializeMessageField(w, "string", &elem); err != nil { return err } } // Write size little endian err = binary.Write(w, binary.LittleEndian, uint32(len(m.Points))) if err != nil { return fmt.Errorf("could not write array length: %s", err) } for _, elem := range m.Points { if err = ros.SerializeMessageField(w, "JointTrajectoryPoint", &elem); err != nil { return err } } return }
// 打包 func PackageData(head PkgHead, body []byte, tail InnerPkgTail) *bytes.Buffer { buf := new(bytes.Buffer) binary.Write(buf, binary.BigEndian, head) binary.Write(buf, binary.BigEndian, body) binary.Write(buf, binary.BigEndian, tail) return buf }
func NewSprite(vertices []float32, program *gg.Program, texture *gg.Texture) (*Sprite, error) { buf := new(bytes.Buffer) if err := binary.Write(buf, binary.LittleEndian, vertices); err != nil { return nil, err } pvbo := gg.CreateBuffer() gg.BindBuffer(gg.ARRAY_BUFFER, pvbo) gg.BufferData(gg.ARRAY_BUFFER, buf.Bytes(), gg.STATIC_DRAW) texVertices := []float32{ 0, 0, 0, 1, 1, 1, 1, 0, } buf.Reset() if err := binary.Write(buf, binary.LittleEndian, texVertices); err != nil { return nil, err } tvbo := gg.CreateBuffer() gg.BindBuffer(gg.ARRAY_BUFFER, tvbo) gg.BufferData(gg.ARRAY_BUFFER, buf.Bytes(), gg.STATIC_DRAW) return &Sprite{ pvbo: pvbo, tvbo: tvbo, program: program, tex: texture, }, nil }
func decryptAES(src, key, privParam []byte, engineBoots, engineTime int32) ( dst []byte, err error) { if len(privParam) != 8 { err = ArgumentError{ Value: len(privParam), Message: "Invalid AES PrivParameter length", } return } block, err := aes.NewCipher(key[:16]) if err != nil { return } var buf bytes.Buffer binary.Write(&buf, binary.BigEndian, engineBoots) binary.Write(&buf, binary.BigEndian, engineTime) iv := append(buf.Bytes(), privParam...) dst = make([]byte, len(src)) mode := cipher.NewCFBDecrypter(block, iv) mode.XORKeyStream(dst, src) return }
func (e *Entry) MarshalBinary() ([]byte, error) { buf := new(bytes.Buffer) // 1 byte Version if err := binary.Write(buf, binary.BigEndian, e.Version); err != nil { return buf.Bytes(), err } // 32 byte ChainID buf.Write(e.ChainID.Bytes()) // ExtIDs if ext, err := e.MarshalExtIDsBinary(); err != nil { return buf.Bytes(), err } else { // 2 byte size of ExtIDs if err := binary.Write(buf, binary.BigEndian, int16(len(ext))); err != nil { return buf.Bytes(), err } // binary ExtIDs buf.Write(ext) } // Content buf.Write(e.Content) return buf.Bytes(), nil }
func serializeV1CertSCTSignatureInput(timestamp uint64, cert ASN1Cert, ext CTExtensions) ([]byte, error) { if err := checkCertificateFormat(cert); err != nil { return nil, err } if err := checkExtensionsFormat(ext); err != nil { return nil, err } var buf bytes.Buffer if err := binary.Write(&buf, binary.BigEndian, V1); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, CertificateTimestampSignatureType); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, timestamp); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, X509LogEntryType); err != nil { return nil, err } if err := writeVarBytes(&buf, cert, CertificateLengthBytes); err != nil { return nil, err } if err := writeVarBytes(&buf, ext, ExtensionsLengthBytes); err != nil { return nil, err } return buf.Bytes(), nil }
func (pack *TxPack) Serialize() ([]byte, error) { var buff bytes.Buffer var err error err = binary.Write(&buff, binary.LittleEndian, pack.Time) if err != nil { return nil, err } err = binary.Write(&buff, binary.LittleEndian, pack.Height) if err != nil { return nil, err } err = binary.Write(&buff, binary.LittleEndian, uint32(len(pack.Txs))) if err != nil { return nil, err } for _, tx := range pack.Txs { var b bytes.Buffer tx.MsgTx().Serialize(&b) err = binary.Write(&buff, binary.LittleEndian, uint32(b.Len())) if err != nil { return nil, err } err = binary.Write(&buff, binary.LittleEndian, b.Bytes()) if err != nil { return nil, err } } return buff.Bytes(), nil }
func serializeV1STHSignatureInput(sth SignedTreeHead) ([]byte, error) { if sth.Version != V1 { return nil, fmt.Errorf("invalid STH version %d", sth.Version) } if sth.TreeSize < 0 { return nil, fmt.Errorf("invalid tree size %d", sth.TreeSize) } if len(sth.SHA256RootHash) != crypto.SHA256.Size() { return nil, fmt.Errorf("invalid TreeHash length, got %d expected %d", len(sth.SHA256RootHash), crypto.SHA256.Size()) } var buf bytes.Buffer if err := binary.Write(&buf, binary.BigEndian, V1); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, TreeHashSignatureType); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, sth.Timestamp); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, sth.TreeSize); err != nil { return nil, err } if err := binary.Write(&buf, binary.BigEndian, sth.SHA256RootHash); err != nil { return nil, err } return buf.Bytes(), nil }
// MultiPublish creates a new Command to write more than one message to a given topic. // This is useful for high-throughput situations to avoid roundtrips and saturate the pipe. func MultiPublish(topic string, bodies [][]byte) (*Command, error) { var params = [][]byte{[]byte(topic)} num := uint32(len(bodies)) bodySize := 4 for _, b := range bodies { bodySize += len(b) + 4 } body := make([]byte, 0, bodySize) buf := bytes.NewBuffer(body) err := binary.Write(buf, binary.BigEndian, &num) if err != nil { return nil, err } for _, b := range bodies { err = binary.Write(buf, binary.BigEndian, int32(len(b))) if err != nil { return nil, err } _, err = buf.Write(b) if err != nil { return nil, err } } return &Command{[]byte("MPUB"), params, buf.Bytes()}, nil }
func (client *Client) HandleLoadGroupOffline(lh *LoadGroupOffline) { messages := storage.LoadGroupOfflineMessage(lh.appid, lh.gid, lh.uid, lh.device_id, GROUP_OFFLINE_LIMIT) result := &MessageResult{status: 0} buffer := new(bytes.Buffer) var count int16 = 0 for _, emsg := range messages { if emsg.msg.cmd == MSG_GROUP_IM { im := emsg.msg.body.(*IMMessage) if im.sender == lh.uid && emsg.device_id == lh.device_id { continue } } count += 1 } binary.Write(buffer, binary.BigEndian, count) for _, emsg := range messages { if emsg.msg.cmd == MSG_GROUP_IM { im := emsg.msg.body.(*IMMessage) if im.sender == lh.uid && emsg.device_id == lh.device_id { continue } } ebuf := client.WriteEMessage(emsg) var size int16 = int16(len(ebuf)) binary.Write(buffer, binary.BigEndian, size) buffer.Write(ebuf) } result.content = buffer.Bytes() msg := &Message{cmd: MSG_RESULT, body: result} SendMessage(client.conn, msg) }
func (m *Bounce) MarshalForSignature() ([]byte, error) { var buf primitives.Buffer binary.Write(&buf, binary.BigEndian, m.Type()) var buff [32]byte copy(buff[:32], []byte(fmt.Sprintf("%32s", m.Name))) buf.Write(buff[:]) binary.Write(&buf, binary.BigEndian, m.Number) t := m.GetTimestamp() data, err := t.MarshalBinary() if err != nil { return nil, err } buf.Write(data) binary.Write(&buf, binary.BigEndian, int32(len(m.Stamps))) for _, ts := range m.Stamps { data, err := ts.MarshalBinary() if err != nil { return nil, err } buf.Write(data) } return buf.DeepCopyBytes(), nil }
func writeAllHeaders(w io.Writer, headers []headerStruct) (err error) { // calculatint total length var totallen uint32 = 4 for _, hdr := range headers { totallen += 4 + 2 + uint32(len(hdr.data)) } // writing err = binary.Write(w, binary.LittleEndian, totallen) if err != nil { return err } for _, hdr := range headers { var headerlen uint32 = 4 + 2 + uint32(len(hdr.data)) err = binary.Write(w, binary.LittleEndian, headerlen) if err != nil { return err } err = binary.Write(w, binary.LittleEndian, hdr.hdrtype) if err != nil { return err } _, err = w.Write(hdr.data) if err != nil { return err } } return nil }
// body is the binary serializable request body. trailer is optional data // following it, such as for BEP 41. func (c *udpClient) write(h *RequestHeader, body interface{}, trailer []byte) (err error) { var buf bytes.Buffer err = binary.Write(&buf, binary.BigEndian, h) if err != nil { panic(err) } if body != nil { err = binary.Write(&buf, binary.BigEndian, body) if err != nil { panic(err) } } _, err = buf.Write(trailer) if err != nil { return } n, err := c.socket.Write(buf.Bytes()) if err != nil { return } if n != buf.Len() { panic("write should send all or error") } return }