Beispiel #1
0
func (bin *mBinaryProto) readVarint(reader io.Reader) (int64, error) {
	if br, ok := reader.(io.ByteReader); ok {
		return binary.ReadVarint(br)
	}
	br := newByteReader(reader, bin.readBuffer)
	return binary.ReadVarint(br)
}
//  0. embedded video
//  1. picture
//  2. pictures
//  3. title
//  4. tags
//  5. categories
//  6. pornstars
//  7. duration in seconds
//  8. views
//  9. upvotes
//  10. downvotes
func SaveRow(row []byte) {
	var video Video

	// Split the columns
	b := bytes.Split(row, []byte(`|`))

	video.SourceName = "pornhub"
	video.Username = "******"
	// video.EmbedCode = EscapeStrings(string(b[0]))
	video.EmbedCode = EscapeString(string(b[0]))
	video.Picture = string(b[1])
	video.Pictures = string(b[2])
	video.Title = string(b[3])
	video.Description = "Watch " + string(b[3])
	video.Tags = string(b[4])
	video.Categories = string(b[5])
	video.Pornstars = string(b[6])
	video.Duration, _ = binary.ReadVarint(bytes.NewBuffer(b[7]))
	video.ViewsCount, _ = binary.ReadVarint(bytes.NewBuffer(b[8]))
	video.Upvotes, _ = binary.ReadVarint(bytes.NewBuffer(b[9]))
	video.Downvotes, _ = binary.ReadVarint(bytes.NewBuffer(b[10]))
	video.CreatedAt = time.Now()
	video.UpdatedAt = time.Now()

	insertVideo(video)
}
Beispiel #3
0
// UnmarshalBinary implements encoding.BinaryUnmarshaler.
func (tr *TimeRange) UnmarshalBinary(buf []byte) error {
	r := bytes.NewReader(buf)
	first, err := binary.ReadVarint(r)
	if err != nil {
		return err
	}
	last, err := binary.ReadVarint(r)
	if err != nil {
		return err
	}
	tr.First = clientmodel.Timestamp(first)
	tr.Last = clientmodel.Timestamp(last)
	return nil
}
Beispiel #4
0
func UnmarshalDeltaNodes(buf []byte, nodes []element.Node) ([]element.Node, error) {
	r := bytes.NewBuffer(buf)
	length, err := binary.ReadVarint(r)
	if err != nil {
		return nil, err
	}

	if int64(cap(nodes)) < length {
		nodes = make([]element.Node, length)
	} else {
		nodes = nodes[:length]
	}

	lastId := int64(0)
	for i := 0; int64(i) < length; i++ {
		id, err := binary.ReadVarint(r)
		if err != nil {
			return nil, err
		}
		id = lastId + id
		nodes[i].Id = id
		lastId = id
	}

	lastLong := int64(0)
	for i := 0; int64(i) < length; i++ {
		long, err := binary.ReadVarint(r)
		if err != nil {
			return nil, err
		}
		long = lastLong + long
		nodes[i].Long = IntToCoord(uint32(long))
		lastLong = long
	}

	lastLat := int64(0)
	for i := 0; int64(i) < length; i++ {
		lat, err := binary.ReadVarint(r)
		if err != nil {
			return nil, err
		}
		lat = lastLat + lat
		nodes[i].Lat = IntToCoord(uint32(lat))
		lastLat = lat
	}

	return nodes, nil
}
func (t *Commit) Unmarshal(rr io.Reader) error {
	var wire byteReader
	var ok bool
	if wire, ok = rr.(byteReader); !ok {
		wire = bufio.NewReader(rr)
	}
	var b [24]byte
	var bs []byte
	bs = b[:12]
	if _, err := io.ReadAtLeast(wire, bs, 12); err != nil {
		return err
	}
	t.LeaderId = int32((uint32(bs[0]) | (uint32(bs[1]) << 8) | (uint32(bs[2]) << 16) | (uint32(bs[3]) << 24)))
	t.Replica = int32((uint32(bs[4]) | (uint32(bs[5]) << 8) | (uint32(bs[6]) << 16) | (uint32(bs[7]) << 24)))
	t.Instance = int32((uint32(bs[8]) | (uint32(bs[9]) << 8) | (uint32(bs[10]) << 16) | (uint32(bs[11]) << 24)))
	alen1, err := binary.ReadVarint(wire)
	if err != nil {
		return err
	}
	t.Command = make([]state.Command, alen1)
	for i := int64(0); i < alen1; i++ {
		t.Command[i].Unmarshal(wire)
	}
	bs = b[:24]
	if _, err := io.ReadAtLeast(wire, bs, 24); err != nil {
		return err
	}
	t.Seq = int32((uint32(bs[0]) | (uint32(bs[1]) << 8) | (uint32(bs[2]) << 16) | (uint32(bs[3]) << 24)))
	t.Deps[0] = int32((uint32(bs[4]) | (uint32(bs[5]) << 8) | (uint32(bs[6]) << 16) | (uint32(bs[7]) << 24)))
	t.Deps[1] = int32((uint32(bs[8]) | (uint32(bs[9]) << 8) | (uint32(bs[10]) << 16) | (uint32(bs[11]) << 24)))
	t.Deps[2] = int32((uint32(bs[12]) | (uint32(bs[13]) << 8) | (uint32(bs[14]) << 16) | (uint32(bs[15]) << 24)))
	t.Deps[3] = int32((uint32(bs[16]) | (uint32(bs[17]) << 8) | (uint32(bs[18]) << 16) | (uint32(bs[19]) << 24)))
	t.Deps[4] = int32((uint32(bs[20]) | (uint32(bs[21]) << 8) | (uint32(bs[22]) << 16) | (uint32(bs[23]) << 24)))
	return nil
}
// rawInt64 should only be used by low-level decoders
func (p *importer) rawInt64() int64 {
	i, err := binary.ReadVarint(p)
	if err != nil {
		panic(fmt.Sprintf("read error: %v", err))
	}
	return i
}
Beispiel #7
0
func (t *Accept) Unmarshal(rr io.Reader) error {
	var wire byteReader
	var ok bool
	if wire, ok = rr.(byteReader); !ok {
		wire = bufio.NewReader(rr)
	}
	var b [12]byte
	var bs []byte
	bs = b[:12]
	if _, err := io.ReadAtLeast(wire, bs, 12); err != nil {
		return err
	}
	t.LeaderId = int32((uint32(bs[0]) | (uint32(bs[1]) << 8) | (uint32(bs[2]) << 16) | (uint32(bs[3]) << 24)))
	t.Instance = int32((uint32(bs[4]) | (uint32(bs[5]) << 8) | (uint32(bs[6]) << 16) | (uint32(bs[7]) << 24)))
	t.Ballot = int32((uint32(bs[8]) | (uint32(bs[9]) << 8) | (uint32(bs[10]) << 16) | (uint32(bs[11]) << 24)))
	alen1, err := binary.ReadVarint(wire)
	if err != nil {
		return err
	}
	t.Command = make([]state.Command, alen1)
	for i := int64(0); i < alen1; i++ {
		t.Command[i].Unmarshal(wire)
	}
	if _, err := io.ReadAtLeast(wire, bs, 12); err != nil {
		return err
	}
	t.LeaseInstance = int32((uint32(bs[0]) | (uint32(bs[1]) << 8) | (uint32(bs[2]) << 16) | (uint32(bs[3]) << 24)))
	t.OriginReplica = int32((uint32(bs[4]) | (uint32(bs[5]) << 8) | (uint32(bs[6]) << 16) | (uint32(bs[7]) << 24)))
	t.PropId = int32((uint32(bs[8]) | (uint32(bs[9]) << 8) | (uint32(bs[10]) << 16) | (uint32(bs[11]) << 24)))
	return nil
}
func (b *BoltDB) GetValue() int64 {
	var retVal int64
	err := b.db.View(func(tx *bolt.Tx) error {
		b := tx.Bucket(demoBucket)
		if b == nil {
			retVal = -1
			return nil
		}
		v := b.Get(demoKey)
		if v == nil {

			retVal = 0
		} else {
			i, err := binary.ReadVarint(bytes.NewBuffer(v))
			if err != nil {
				return err
			}
			retVal = i
		}
		return nil
	})
	if err != nil {
		log.Fatal(err)
	}
	return retVal
}
Beispiel #9
0
// rawInt64 should only be used by low-level decoders
func (p *importer) rawInt64() int64 {
	i, err := binary.ReadVarint(p)
	if err != nil {
		Fatalf("importer: read error: %v", err)
	}
	return i
}
Beispiel #10
0
func DecodeOld(str string) (int64, error) {
	data, err := base64.StdEncoding.DecodeString(str)
	if err != nil {
		return 0, err
	}
	return binary.ReadVarint(bytes.NewReader(data))
}
Beispiel #11
0
// Testing out how to hash some object
func main() {
	fmt.Println("Hello, playground")

	// sha := sha256.New()

	result := sha256.Sum256([]byte("foobar"))
	length := len(result)
	fmt.Printf("%d\n", length)
	fmt.Printf("%x\n", result)

	part0 := result[:16]
	fmt.Printf("%d\n", len(part0))
	fmt.Printf("%x\n", part0)

	// converting byte array to signed int
	buf := bytes.NewBuffer(part0)
	intPart0, _ := binary.ReadVarint(buf)
	// note: probably want unsigned int instead...

	fmt.Printf("%d\n\n\n", intPart0)

	part1 := result[16:]
	fmt.Printf("%d\n", len(part1))
	fmt.Printf("%x\n", part1)

	b := NewBloomFilterStringKeyed(32, 10)

	fmt.Println(b.byteCapacity)
	fmt.Println(b.numHashes)
	fmt.Println(b.bitHashTable)

	b.AddKey("foo")

}
func (t *PrepareReply) Unmarshal(rr io.Reader) error {
	var wire byteReader
	var ok bool
	if wire, ok = rr.(byteReader); !ok {
		wire = bufio.NewReader(rr)
	}
	var b [10]byte
	var bs []byte
	bs = b[:9]
	if _, err := io.ReadAtLeast(wire, bs, 9); err != nil {
		return err
	}
	t.Balnum = int32((uint32(bs[0]) | (uint32(bs[1]) << 8) | (uint32(bs[2]) << 16) | (uint32(bs[3]) << 24)))
	t.OK = uint8(bs[4])
	t.Ballot = int32((uint32(bs[5]) | (uint32(bs[6]) << 8) | (uint32(bs[7]) << 16) | (uint32(bs[8]) << 24)))
	alen1, err := binary.ReadVarint(wire)
	if err != nil {
		return err
	}
	t.Cstruct = make([]int32, alen1)
	for i := int64(0); i < alen1; i++ {
		bs = b[:4]
		if _, err := io.ReadAtLeast(wire, bs, 4); err != nil {
			return err
		}
		t.Cstruct[i] = int32((uint32(bs[0]) | (uint32(bs[1]) << 8) | (uint32(bs[2]) << 16) | (uint32(bs[3]) << 24)))
	}
	return nil
}
Beispiel #13
0
//The go routine here, keep waiting messages from connected client Blocking.
func (client *Client) Read(mp *MessagePasser) {
	for {
		//line, err := client.reader.ReadBytes('\xfe')
		length, err := binary.ReadVarint(client.reader)

		if err != nil {
			client.rethrowError(mp)
			mp.RemoveMapping(client.IP)
			mp.RemoveMapping(client.name)
			return
		}
		buffer := make([]byte, length)
		client.reader.Read(buffer)

		msg := new(Message)
		msg.Deserialize(buffer)

		err = msg.Deserialize(buffer)
		if err != nil {
			fmt.Println("err is " + err.Error())
		}
		client.addToClients(msg, mp.connections.clients)
		mp.Incoming <- msg // Since there is only one socket, directly put all the received
		// msgs into the global receiving channel (message queue)
	}
}
func (bed BinaryVarintEncoderDecoder) Decode(r io.Reader, n *big.Float) error {
	var isInteger int8
	var f float64
	var exponent int32
	n.SetUint64(0)

	if err := binary.Read(r, binary.BigEndian, &isInteger); err != nil {
		return err
	}

	if isInteger <= 0 {
		var x int64
		var err error
		if x, err = binary.ReadVarint(miniByteReader{r}); err != nil {
			return err
		}
		n.SetInt64(x)
		n.SetPrec(ENCODER_DECODER_PREC)
		return nil
	} else {
		if err := binary.Read(r, binary.BigEndian, &f); err != nil {
			return err
		}
		if err := binary.Read(r, binary.BigEndian, &exponent); err != nil {
			return err
		}
		bed.tmp.SetFloat64(f)
		bed.tmp.SetPrec(ENCODER_DECODER_PREC)
		n.SetMantExp(bed.tmp, int(exponent))
		return nil
	}
}
Beispiel #15
0
func init() {
	// seed math.random from crypto.random
	seedBytes, _ := makeRandom(8)
	seedBuf := bytes.NewBuffer(seedBytes)
	n64, _ := binary.ReadVarint(seedBuf)
	mrand.Seed(n64)
}
Beispiel #16
0
// rawInt64 should only be used by low-level decoders.
func (p *importer) rawInt64() int64 {
	i, err := binary.ReadVarint(p)
	if err != nil {
		formatErrorf("read error: %v", err)
	}
	return i
}
Beispiel #17
0
// ReadVarIntAndDecode64 reads a varint from r to a uint64
// and then zigzag decodes it to an int64 value.
func (r *Reader) ReadVarint() int64 {
	v, err := binary.ReadVarint(r.br)
	if err != nil {
		r.err = err
	}
	return v
}
Beispiel #18
0
// Reads an encrypted message from the reader expecting the following structure:
// The first two bytes are the length(x) of the encrypted message.
// The next 24 bytes are the nonce.
// The next x bytes is the encrypted message.
func (s *SecureReader) Read(p []byte) (int, error) {
	er := &errReader{r: s.reader}

	plen := make([]byte, 2)
	er.read(plen)

	payloadLen, err := binary.ReadVarint(bytes.NewBuffer(plen))
	if err != nil {
		return 0, errors.New("Invalid length bytes")
	}

	nonce := make([]byte, 24)
	er.read(nonce)

	payload := make([]byte, payloadLen)
	er.read(payload)

	if er.err != nil {
		return 0, er.err
	}

	nonceArray := &[24]byte{}
	copy(nonceArray[:], nonce)

	message, success := box.Open(nil, payload, nonceArray, s.pub, s.priv)
	if !success {
		return 0, errors.New("Decrypt failure")
	}

	copy(p, message)
	return len(message), nil
}
func (b *BoltDB) Increment() int64 {
	buf := make([]byte, 8)
	var retVal int64
	err := b.db.Update(func(tx *bolt.Tx) error {
		b, err := tx.CreateBucketIfNotExists(demoBucket)
		if err != nil {
			log.Fatal(err)
		}
		v := b.Get(demoKey)
		if v == nil {
			binary.PutVarint(buf, 0)
			retVal = 0
		} else {
			i, err := binary.ReadVarint(bytes.NewBuffer(v))
			if err != nil {
				log.Fatal(err)
			}
			i++
			retVal = i
			binary.PutVarint(buf, i)
		}
		err = b.Put(demoKey, buf)
		return err
	})
	if err != nil {
		log.Fatal(err)
	}

	return retVal
}
Beispiel #20
0
func (t *Commit) Unmarshal(rr io.Reader) error {
	var wire byteReader
	var ok bool
	if wire, ok = rr.(byteReader); !ok {
		wire = bufio.NewReader(rr)
	}
	var b [12]byte
	var bs []byte
	bs = b[:12]
	if _, err := io.ReadAtLeast(wire, bs, 12); err != nil {
		return err
	}
	t.LeaderId = int32((uint32(bs[0]) | (uint32(bs[1]) << 8) | (uint32(bs[2]) << 16) | (uint32(bs[3]) << 24)))
	t.Instance = int32((uint32(bs[4]) | (uint32(bs[5]) << 8) | (uint32(bs[6]) << 16) | (uint32(bs[7]) << 24)))
	t.Ballot = int32((uint32(bs[8]) | (uint32(bs[9]) << 8) | (uint32(bs[10]) << 16) | (uint32(bs[11]) << 24)))
	alen1, err := binary.ReadVarint(wire)
	if err != nil {
		return err
	}
	t.LeaseUpdate = make([]qleaseproto.LeaseMetadata, alen1)
	for i := int64(0); i < alen1; i++ {
		t.LeaseUpdate[i].Unmarshal(wire)
	}
	return nil
}
Beispiel #21
0
func BytesToInt(buf []byte) int64 {
	nbuf := bytes.NewBuffer(buf)
	n, err := binary.ReadVarint(nbuf)
	if err != nil {
		return -1
	}
	return n
}
Beispiel #22
0
func validatePrivateKey(key []byte) error {
	keyInt, _ := binary.ReadVarint(bytes.NewBuffer(key))
	if keyInt == 0 || bytes.Compare(key, curveParams.N.Bytes()) >= 0 {
		return errors.New("Invalid seed")
	}

	return nil
}
Beispiel #23
0
// decodeMsg decodes either a *Chunk, *Sync or *Ack object from the byte array.
func decodeMsg(q []byte) (interface{}, error) {
	r := bytes.NewReader(q)
	// MsgKind
	msgkind, err := r.ReadByte()
	if err != nil {
		return nil, err
	}
	msgKind := MsgKind(msgkind)
	// Switch
	switch msgKind {
	case CHUNK:
		msg := &Chunk{}
		// SeqNo
		seqno, err := binary.ReadVarint(r)
		if err != nil {
			return nil, err
		}
		msg.seqno = SeqNo(seqno)
		// Chunk
		msg.chunk, err = ioutil.ReadAll(r)
		if err != nil {
			panic("u")
		}
		return msg, nil

	case SYNC:
		msg := &Sync{}
		nackd, err := binary.ReadVarint(r)
		if err != nil {
			return nil, err
		}
		msg.NAckd = SeqNo(nackd)
		return msg, nil

	case ACK:
		msg := &Ack{}
		nackd, err := binary.ReadVarint(r)
		if err != nil {
			return nil, err
		}
		msg.NAckd = SeqNo(nackd)
		return msg, nil
	}
	return nil, chain.ErrMisbehave
}
Beispiel #24
0
func OpenEmbedFs(file *os.File) (*embedFs, error) {
	stat, err := file.Stat()
	if err != nil {
		return nil, err
	}

	_, err = file.Seek(-4, os.SEEK_END)
	if err != nil {
		return nil, err
	}

	offset, err := binary.ReadVarint(bufio.NewReader(file))
	if err != nil {
		panic(err)
	}

	emfs := &embedFs{
		files:     make([]*embedFsEntry, 0),
		index:     make(map[string]*embedFsEntry, 0),
		origin:    file,
		tarOffset: offset,
		tarWriter: tar.NewWriter(file),
	}

	if offset >= stat.Size() || offset <= 0 {
		emfs.tarOffset = stat.Size()
	}

	file.Seek(emfs.tarOffset, os.SEEK_SET)

	tr := tar.NewReader(file)

	for {
		hdr, err := tr.Next()
		if err == io.EOF {
			break
		}

		if err != nil {
			emfs.tarOffset = stat.Size()
			return emfs, nil
		}

		seek, _ := file.Seek(0, os.SEEK_CUR)
		entry := &embedFsEntry{
			name:   hdr.Name,
			offset: seek,
			header: hdr,
		}

		emfs.files = append(emfs.files, entry)
		emfs.index[entry.name] = entry
	}

	return emfs, nil
}
Beispiel #25
0
func (t *Trace) readRecord() error {
	deltaPC, err := binary.ReadVarint(t.blockReader)
	if err != nil {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
		return err
	}
	deltaEA, err := binary.ReadVarint(t.blockReader)
	if err != nil {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
		return err
	}

	t.rec.N = t.recno
	t.rec.PC += uint64(deltaPC)
	t.rec.EA += uint64(deltaEA)
	t.recno++
	return nil
}
Beispiel #26
0
func UnmarshalIdRefsBunch(buf []byte) []element.IdRefs {
	r := bytes.NewBuffer(buf)
	n, err := binary.ReadUvarint(r)
	if err != nil {
		return nil
	}

	idRefs := make([]element.IdRefs, n)

	last := int64(0)
	for i := 0; uint64(i) < n; i++ {
		idRefs[i].Id, err = binary.ReadVarint(r)
		if err != nil {
			panic(err)
		}
		idRefs[i].Id += last
		last = idRefs[i].Id
	}
	var numRefs uint64
	for i := 0; uint64(i) < n; i++ {
		numRefs, err = binary.ReadUvarint(r)
		if err != nil {
			panic(err)
		}
		idRefs[i].Refs = make([]int64, numRefs)
	}
	last = 0
	for idIdx := 0; uint64(idIdx) < n; idIdx++ {
		for refIdx := 0; refIdx < len(idRefs[idIdx].Refs); refIdx++ {
			idRefs[idIdx].Refs[refIdx], err = binary.ReadVarint(r)
			if err != nil {
				panic(err)
			}
			idRefs[idIdx].Refs[refIdx] += last
			last = idRefs[idIdx].Refs[refIdx]
		}
	}
	return idRefs
}
Beispiel #27
0
// decodeString decodes a string encoded by encodeString.
func decodeString(b byteReader) (string, error) {
	length, err := binary.ReadVarint(b)
	if err != nil {
		return "", err
	}

	buf := getBuf(int(length))
	defer putBuf(buf)

	if _, err := io.ReadFull(b, buf); err != nil {
		return "", err
	}
	return string(buf), nil
}
func init() {
    if urandom, err := os.Open("/dev/urandom"); err != nil {
        return
    } else {
        buf := make([]byte, 8)
        if _, err := urandom.Read(buf); err == nil {
            buf_reader := bytes.NewReader(buf)
            if seed, err := binary.ReadVarint(buf_reader); err == nil {
                rand.Seed(seed)
            }
        }
        urandom.Close()
    }
}
Beispiel #29
0
func (t *LeaseMetadata) Unmarshal(rr io.Reader) error {
	var wire byteReader
	var ok bool
	if wire, ok = rr.(byteReader); !ok {
		wire = bufio.NewReader(rr)
	}
	var b [10]byte
	var bs []byte
	alen1, err := binary.ReadVarint(wire)
	if err != nil {
		return err
	}
	t.Quorum = make([]int32, alen1)
	for i := int64(0); i < alen1; i++ {
		bs = b[:4]
		if _, err := io.ReadAtLeast(wire, bs, 4); err != nil {
			return err
		}
		t.Quorum[i] = int32((uint32(bs[0]) | (uint32(bs[1]) << 8) | (uint32(bs[2]) << 16) | (uint32(bs[3]) << 24)))
	}
	alen2, err := binary.ReadVarint(wire)
	if err != nil {
		return err
	}
	t.ObjectKeys = make([]state.Key, alen2)
	for i := int64(0); i < alen2; i++ {
		t.ObjectKeys[i].Unmarshal(wire)
	}
	bs = b[:2]
	if _, err := io.ReadAtLeast(wire, bs, 2); err != nil {
		return err
	}
	t.IgnoreReplicas = uint8(bs[0])
	t.ReinstateReplicas = uint8(bs[1])
	return nil
}
Beispiel #30
0
func (n *Node) extractMeta() (*nodeMeta, error) {
	md := &nodeMeta{}
	if len(n.Node.Meta) < minMdLen {
		return nil, fmt.Errorf("Not enough bytes to extract metadata")
	}
	// ready
	md.ready = n.Node.Meta[0] == 1
	// sortBy
	var err error
	if md.sortBy, err = binary.ReadVarint(bytes.NewReader(n.Node.Meta[1:])); err != nil {
		return nil, fmt.Errorf("extractMeta(): sortBy: %v", err)
	}
	// user
	md.user = n.Node.Meta[minMdLen:]
	return md, nil
}